// $ANTLR 3.1.1 G:\\downloads\\antlr\\cs.g 2010-12-24 16:54:06
// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
namespace 
    AntlrCSharp

{

using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;


using Antlr.Runtime.Tree;

public partial class csParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"IDENTIFIER", 
		"Real_literal", 
		"NUMBER", 
		"Hex_number", 
		"Character_literal", 
		"STRINGLITERAL", 
		"Verbatim_string_literal", 
		"TRUE", 
		"FALSE", 
		"NULL", 
		"DOT", 
		"PTR", 
		"MINUS", 
		"GT", 
		"USING", 
		"ENUM", 
		"IF", 
		"ELIF", 
		"ENDIF", 
		"DEFINE", 
		"UNDEF", 
		"SEMI", 
		"RPAREN", 
		"WS", 
		"TS", 
		"DOC_LINE_COMMENT", 
		"LINE_COMMENT", 
		"COMMENT", 
		"EscapeSequence", 
		"Verbatim_string_literal_character", 
		"Decimal_digits", 
		"INTEGER_TYPE_SUFFIX", 
		"Decimal_integer_literal", 
		"GooBallIdentifier", 
		"GooBall", 
		"IdentifierStart", 
		"IdentifierPart", 
		"Exponent_part", 
		"Real_type_suffix", 
		"Pragma", 
		"PP_CONDITIONAL", 
		"PREPROCESSOR_DIRECTIVE", 
		"IF_TOKEN", 
		"DEFINE_TOKEN", 
		"ELSE_TOKEN", 
		"ENDIF_TOKEN", 
		"UNDEF_TOKEN", 
		"PP_EXPRESSION", 
		"PP_OR_EXPRESSION", 
		"PP_AND_EXPRESSION", 
		"PP_EQUALITY_EXPRESSION", 
		"PP_UNARY_EXPRESSION", 
		"PP_PRIMARY_EXPRESSION", 
		"HEX_DIGIT", 
		"HEX_DIGITS", 
		"DECIMAL_DIGIT", 
		"Sign", 
		"'namespace'", 
		"'{'", 
		"'}'", 
		"'extern'", 
		"'alias'", 
		"'='", 
		"'partial'", 
		"'new'", 
		"'public'", 
		"'protected'", 
		"'private'", 
		"'internal'", 
		"'unsafe'", 
		"'abstract'", 
		"'sealed'", 
		"'static'", 
		"'readonly'", 
		"'volatile'", 
		"'virtual'", 
		"'override'", 
		"'const'", 
		"'void'", 
		"'this'", 
		"'::'", 
		"'base'", 
		"'['", 
		"']'", 
		"'('", 
		"','", 
		"':'", 
		"'out'", 
		"'ref'", 
		"'sizeof'", 
		"'checked'", 
		"'unchecked'", 
		"'default'", 
		"'delegate'", 
		"'typeof'", 
		"'<'", 
		"'*'", 
		"'?'", 
		"'++'", 
		"'--'", 
		"'+'", 
		"'!'", 
		"'~'", 
		"'+='", 
		"'-='", 
		"'*='", 
		"'/='", 
		"'%='", 
		"'&='", 
		"'|='", 
		"'^='", 
		"'<<='", 
		"'>='", 
		"'&'", 
		"'/'", 
		"'%'", 
		"'<<'", 
		"'<='", 
		"'is'", 
		"'as'", 
		"'=='", 
		"'!='", 
		"'^'", 
		"'|'", 
		"'&&'", 
		"'||'", 
		"'??'", 
		"'=>'", 
		"'into'", 
		"'from'", 
		"'in'", 
		"'join'", 
		"'on'", 
		"'equals'", 
		"'let'", 
		"'orderby'", 
		"'ascending'", 
		"'descending'", 
		"'select'", 
		"'group'", 
		"'by'", 
		"'where'", 
		"'assembly'", 
		"'module'", 
		"'field'", 
		"'event'", 
		"'method'", 
		"'param'", 
		"'property'", 
		"'return'", 
		"'type'", 
		"'class'", 
		"'get'", 
		"'set'", 
		"'add'", 
		"'remove'", 
		"'sbyte'", 
		"'byte'", 
		"'short'", 
		"'ushort'", 
		"'int'", 
		"'uint'", 
		"'long'", 
		"'ulong'", 
		"'char'", 
		"'struct'", 
		"'__arglist'", 
		"'params'", 
		"'interface'", 
		"'operator'", 
		"'implicit'", 
		"'explicit'", 
		"'fixed'", 
		"'var'", 
		"'dynamic'", 
		"'stackalloc'", 
		"'else'", 
		"'switch'", 
		"'case'", 
		"'while'", 
		"'do'", 
		"'for'", 
		"'foreach'", 
		"'break'", 
		"'continue'", 
		"'goto'", 
		"'throw'", 
		"'try'", 
		"'catch'", 
		"'finally'", 
		"'lock'", 
		"'yield'", 
		"'bool'", 
		"'decimal'", 
		"'double'", 
		"'float'", 
		"'object'", 
		"'string'", 
		"'pragma'"
    };

    public const int DECIMAL_DIGIT = 59;
    public const int T__159 = 159;
    public const int T__158 = 158;
    public const int Character_literal = 8;
    public const int T__160 = 160;
    public const int T__167 = 167;
    public const int EOF = -1;
    public const int T__168 = 168;
    public const int T__165 = 165;
    public const int T__166 = 166;
    public const int T__163 = 163;
    public const int T__164 = 164;
    public const int T__161 = 161;
    public const int T__162 = 162;
    public const int ELSE_TOKEN = 48;
    public const int T__93 = 93;
    public const int T__94 = 94;
    public const int T__91 = 91;
    public const int RPAREN = 26;
    public const int T__92 = 92;
    public const int T__148 = 148;
    public const int T__147 = 147;
    public const int T__90 = 90;
    public const int T__149 = 149;
    public const int USING = 18;
    public const int PP_AND_EXPRESSION = 53;
    public const int Sign = 60;
    public const int T__154 = 154;
    public const int T__155 = 155;
    public const int T__156 = 156;
    public const int T__99 = 99;
    public const int T__157 = 157;
    public const int T__98 = 98;
    public const int T__150 = 150;
    public const int T__97 = 97;
    public const int T__151 = 151;
    public const int T__96 = 96;
    public const int T__152 = 152;
    public const int T__95 = 95;
    public const int T__153 = 153;
    public const int T__139 = 139;
    public const int T__138 = 138;
    public const int T__137 = 137;
    public const int T__136 = 136;
    public const int T__80 = 80;
    public const int T__81 = 81;
    public const int T__82 = 82;
    public const int T__83 = 83;
    public const int NUMBER = 6;
    public const int Decimal_integer_literal = 36;
    public const int DEFINE_TOKEN = 47;
    public const int T__141 = 141;
    public const int T__85 = 85;
    public const int T__142 = 142;
    public const int T__84 = 84;
    public const int T__87 = 87;
    public const int T__140 = 140;
    public const int T__86 = 86;
    public const int T__145 = 145;
    public const int T__89 = 89;
    public const int T__146 = 146;
    public const int T__88 = 88;
    public const int UNDEF_TOKEN = 50;
    public const int T__143 = 143;
    public const int T__144 = 144;
    public const int T__126 = 126;
    public const int ENDIF_TOKEN = 49;
    public const int T__125 = 125;
    public const int T__128 = 128;
    public const int T__127 = 127;
    public const int T__71 = 71;
    public const int WS = 27;
    public const int T__129 = 129;
    public const int T__72 = 72;
    public const int PP_PRIMARY_EXPRESSION = 56;
    public const int T__70 = 70;
    public const int GT = 17;
    public const int PP_EQUALITY_EXPRESSION = 54;
    public const int T__76 = 76;
    public const int T__75 = 75;
    public const int T__130 = 130;
    public const int T__74 = 74;
    public const int T__131 = 131;
    public const int T__73 = 73;
    public const int T__132 = 132;
    public const int T__133 = 133;
    public const int T__79 = 79;
    public const int T__134 = 134;
    public const int T__78 = 78;
    public const int T__135 = 135;
    public const int T__77 = 77;
    public const int T__118 = 118;
    public const int T__119 = 119;
    public const int T__116 = 116;
    public const int T__117 = 117;
    public const int T__114 = 114;
    public const int T__115 = 115;
    public const int T__124 = 124;
    public const int T__123 = 123;
    public const int T__122 = 122;
    public const int T__121 = 121;
    public const int T__120 = 120;
    public const int T__202 = 202;
    public const int T__107 = 107;
    public const int T__108 = 108;
    public const int T__109 = 109;
    public const int PREPROCESSOR_DIRECTIVE = 45;
    public const int T__103 = 103;
    public const int T__104 = 104;
    public const int T__105 = 105;
    public const int T__106 = 106;
    public const int T__111 = 111;
    public const int T__110 = 110;
    public const int T__113 = 113;
    public const int T__112 = 112;
    public const int TS = 28;
    public const int HEX_DIGIT = 57;
    public const int T__102 = 102;
    public const int T__101 = 101;
    public const int T__100 = 100;
    public const int MINUS = 16;
    public const int SEMI = 25;
    public const int Hex_number = 7;
    public const int ENUM = 19;
    public const int STRINGLITERAL = 9;
    public const int PP_UNARY_EXPRESSION = 55;
    public const int PP_OR_EXPRESSION = 52;
    public const int ENDIF = 22;
    public const int COMMENT = 31;
    public const int LINE_COMMENT = 30;
    public const int NULL = 13;
    public const int IdentifierStart = 39;
    public const int Verbatim_string_literal = 10;
    public const int IF_TOKEN = 46;
    public const int ELIF = 21;
    public const int T__200 = 200;
    public const int T__201 = 201;
    public const int PP_CONDITIONAL = 44;
    public const int FALSE = 12;
    public const int EscapeSequence = 32;
    public const int INTEGER_TYPE_SUFFIX = 35;
    public const int T__68 = 68;
    public const int T__69 = 69;
    public const int T__66 = 66;
    public const int T__67 = 67;
    public const int T__64 = 64;
    public const int T__65 = 65;
    public const int T__62 = 62;
    public const int Real_literal = 5;
    public const int T__63 = 63;
    public const int PP_EXPRESSION = 51;
    public const int GooBall = 38;
    public const int T__61 = 61;
    public const int DEFINE = 23;
    public const int IF = 20;
    public const int Exponent_part = 41;
    public const int T__199 = 199;
    public const int T__198 = 198;
    public const int T__197 = 197;
    public const int T__196 = 196;
    public const int T__195 = 195;
    public const int T__194 = 194;
    public const int T__193 = 193;
    public const int T__192 = 192;
    public const int T__191 = 191;
    public const int T__190 = 190;
    public const int IDENTIFIER = 4;
    public const int UNDEF = 24;
    public const int DOT = 14;
    public const int IdentifierPart = 40;
    public const int T__184 = 184;
    public const int T__183 = 183;
    public const int T__186 = 186;
    public const int T__185 = 185;
    public const int T__188 = 188;
    public const int T__187 = 187;
    public const int DOC_LINE_COMMENT = 29;
    public const int T__189 = 189;
    public const int GooBallIdentifier = 37;
    public const int T__180 = 180;
    public const int T__182 = 182;
    public const int T__181 = 181;
    public const int Pragma = 43;
    public const int Verbatim_string_literal_character = 33;
    public const int TRUE = 11;
    public const int PTR = 15;
    public const int T__175 = 175;
    public const int T__174 = 174;
    public const int T__173 = 173;
    public const int T__172 = 172;
    public const int T__179 = 179;
    public const int T__178 = 178;
    public const int T__177 = 177;
    public const int Decimal_digits = 34;
    public const int T__176 = 176;
    public const int T__171 = 171;
    public const int T__170 = 170;
    public const int Real_type_suffix = 42;
    public const int HEX_DIGITS = 58;
    public const int T__169 = 169;

    // delegates
    // delegators



        public csParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public csParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();
            this.state.ruleMemo = new Hashtable[356+1];
             
             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return csParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "G:\\downloads\\antlr\\cs.g"; }
    }


    	protected bool is_class_modifier() 
    	{
    		return false;
    	}


    public class compilation_unit_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "compilation_unit"
    // G:\\downloads\\antlr\\cs.g:40:1: compilation_unit : namespace_body[true] ;
    public csParser.compilation_unit_return compilation_unit() // throws RecognitionException [1]
    {   
        csParser.compilation_unit_return retval = new csParser.compilation_unit_return();
        retval.Start = input.LT(1);
        int compilation_unit_StartIndex = input.Index();
        object root_0 = null;

        csParser.namespace_body_return namespace_body1 = default(csParser.namespace_body_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 1) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:40:17: ( namespace_body[true] )
            // G:\\downloads\\antlr\\cs.g:41:2: namespace_body[true]
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_namespace_body_in_compilation_unit88);
            	namespace_body1 = namespace_body(true);
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_body1.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 1, compilation_unit_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "compilation_unit"

    public class namespace_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "namespace_declaration"
    // G:\\downloads\\antlr\\cs.g:43:1: namespace_declaration : 'namespace' qualified_identifier namespace_block ( ';' )? ;
    public csParser.namespace_declaration_return namespace_declaration() // throws RecognitionException [1]
    {   
        csParser.namespace_declaration_return retval = new csParser.namespace_declaration_return();
        retval.Start = input.LT(1);
        int namespace_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal2 = null;
        IToken char_literal5 = null;
        csParser.qualified_identifier_return qualified_identifier3 = default(csParser.qualified_identifier_return);

        csParser.namespace_block_return namespace_block4 = default(csParser.namespace_block_return);


        object string_literal2_tree=null;
        object char_literal5_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 2) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:43:22: ( 'namespace' qualified_identifier namespace_block ( ';' )? )
            // G:\\downloads\\antlr\\cs.g:44:2: 'namespace' qualified_identifier namespace_block ( ';' )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal2=(IToken)Match(input,61,FOLLOW_61_in_namespace_declaration97); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal2_tree = (object)adaptor.Create(string_literal2);
            		adaptor.AddChild(root_0, string_literal2_tree);
            	}
            	PushFollow(FOLLOW_qualified_identifier_in_namespace_declaration101);
            	qualified_identifier3 = qualified_identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qualified_identifier3.Tree);
            	PushFollow(FOLLOW_namespace_block_in_namespace_declaration105);
            	namespace_block4 = namespace_block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_block4.Tree);
            	// G:\\downloads\\antlr\\cs.g:44:57: ( ';' )?
            	int alt1 = 2;
            	int LA1_0 = input.LA(1);

            	if ( (LA1_0 == SEMI) )
            	{
            	    alt1 = 1;
            	}
            	switch (alt1) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:44:57: ';'
            	        {
            	        	char_literal5=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_namespace_declaration109); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal5_tree = (object)adaptor.Create(char_literal5);
            	        		adaptor.AddChild(root_0, char_literal5_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 2, namespace_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "namespace_declaration"

    public class namespace_block_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "namespace_block"
    // G:\\downloads\\antlr\\cs.g:45:1: namespace_block : '{' namespace_body[false] '}' ;
    public csParser.namespace_block_return namespace_block() // throws RecognitionException [1]
    {   
        csParser.namespace_block_return retval = new csParser.namespace_block_return();
        retval.Start = input.LT(1);
        int namespace_block_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal6 = null;
        IToken char_literal8 = null;
        csParser.namespace_body_return namespace_body7 = default(csParser.namespace_body_return);


        object char_literal6_tree=null;
        object char_literal8_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 3) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:45:16: ( '{' namespace_body[false] '}' )
            // G:\\downloads\\antlr\\cs.g:46:2: '{' namespace_body[false] '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal6=(IToken)Match(input,62,FOLLOW_62_in_namespace_block118); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal6_tree = (object)adaptor.Create(char_literal6);
            		adaptor.AddChild(root_0, char_literal6_tree);
            	}
            	PushFollow(FOLLOW_namespace_body_in_namespace_block122);
            	namespace_body7 = namespace_body(false);
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_body7.Tree);
            	char_literal8=(IToken)Match(input,63,FOLLOW_63_in_namespace_block127); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal8_tree = (object)adaptor.Create(char_literal8);
            		adaptor.AddChild(root_0, char_literal8_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 3, namespace_block_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "namespace_block"

    public class namespace_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "namespace_body"
    // G:\\downloads\\antlr\\cs.g:47:1: namespace_body[bool bGlobal] : ( extern_alias_directives )? ( using_directives )? ( global_attributes )? ( namespace_member_declarations )? ;
    public csParser.namespace_body_return namespace_body(bool bGlobal) // throws RecognitionException [1]
    {   
        csParser.namespace_body_return retval = new csParser.namespace_body_return();
        retval.Start = input.LT(1);
        int namespace_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.extern_alias_directives_return extern_alias_directives9 = default(csParser.extern_alias_directives_return);

        csParser.using_directives_return using_directives10 = default(csParser.using_directives_return);

        csParser.global_attributes_return global_attributes11 = default(csParser.global_attributes_return);

        csParser.namespace_member_declarations_return namespace_member_declarations12 = default(csParser.namespace_member_declarations_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 4) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:47:29: ( ( extern_alias_directives )? ( using_directives )? ( global_attributes )? ( namespace_member_declarations )? )
            // G:\\downloads\\antlr\\cs.g:48:2: ( extern_alias_directives )? ( using_directives )? ( global_attributes )? ( namespace_member_declarations )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:48:2: ( extern_alias_directives )?
            	int alt2 = 2;
            	int LA2_0 = input.LA(1);

            	if ( (LA2_0 == 64) )
            	{
            	    int LA2_1 = input.LA(2);

            	    if ( (LA2_1 == 65) )
            	    {
            	        alt2 = 1;
            	    }
            	}
            	switch (alt2) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:48:2: extern_alias_directives
            	        {
            	        	PushFollow(FOLLOW_extern_alias_directives_in_namespace_body136);
            	        	extern_alias_directives9 = extern_alias_directives();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, extern_alias_directives9.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:48:29: ( using_directives )?
            	int alt3 = 2;
            	int LA3_0 = input.LA(1);

            	if ( (LA3_0 == USING) )
            	{
            	    alt3 = 1;
            	}
            	switch (alt3) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:48:29: using_directives
            	        {
            	        	PushFollow(FOLLOW_using_directives_in_namespace_body141);
            	        	using_directives10 = using_directives();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_directives10.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:48:49: ( global_attributes )?
            	int alt4 = 2;
            	int LA4_0 = input.LA(1);

            	if ( (LA4_0 == 86) )
            	{
            	    int LA4_1 = input.LA(2);

            	    if ( ((LA4_1 >= 146 && LA4_1 <= 147)) )
            	    {
            	        int LA4_3 = input.LA(3);

            	        if ( (LA4_3 == 90) )
            	        {
            	            alt4 = 1;
            	        }
            	    }
            	}
            	switch (alt4) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:48:49: global_attributes
            	        {
            	        	PushFollow(FOLLOW_global_attributes_in_namespace_body146);
            	        	global_attributes11 = global_attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attributes11.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:48:70: ( namespace_member_declarations )?
            	int alt5 = 2;
            	int LA5_0 = input.LA(1);

            	if ( (LA5_0 == ENUM || LA5_0 == 61 || LA5_0 == 64 || (LA5_0 >= 67 && LA5_0 <= 80) || LA5_0 == 86 || LA5_0 == 97 || LA5_0 == 155 || LA5_0 == 169 || LA5_0 == 172) )
            	{
            	    alt5 = 1;
            	}
            	switch (alt5) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:48:70: namespace_member_declarations
            	        {
            	        	PushFollow(FOLLOW_namespace_member_declarations_in_namespace_body151);
            	        	namespace_member_declarations12 = namespace_member_declarations();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_member_declarations12.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 4, namespace_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "namespace_body"

    public class extern_alias_directives_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "extern_alias_directives"
    // G:\\downloads\\antlr\\cs.g:49:1: extern_alias_directives : ( extern_alias_directive )+ ;
    public csParser.extern_alias_directives_return extern_alias_directives() // throws RecognitionException [1]
    {   
        csParser.extern_alias_directives_return retval = new csParser.extern_alias_directives_return();
        retval.Start = input.LT(1);
        int extern_alias_directives_StartIndex = input.Index();
        object root_0 = null;

        csParser.extern_alias_directive_return extern_alias_directive13 = default(csParser.extern_alias_directive_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 5) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:49:24: ( ( extern_alias_directive )+ )
            // G:\\downloads\\antlr\\cs.g:50:2: ( extern_alias_directive )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:50:2: ( extern_alias_directive )+
            	int cnt6 = 0;
            	do 
            	{
            	    int alt6 = 2;
            	    int LA6_0 = input.LA(1);

            	    if ( (LA6_0 == 64) )
            	    {
            	        int LA6_2 = input.LA(2);

            	        if ( (LA6_2 == 65) )
            	        {
            	            alt6 = 1;
            	        }


            	    }


            	    switch (alt6) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:50:2: extern_alias_directive
            			    {
            			    	PushFollow(FOLLOW_extern_alias_directive_in_extern_alias_directives160);
            			    	extern_alias_directive13 = extern_alias_directive();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, extern_alias_directive13.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt6 >= 1 ) goto loop6;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(6, input);
            		            throw eee;
            	    }
            	    cnt6++;
            	} while (true);

            	loop6:
            		;	// Stops C# compiler whinging that label 'loop6' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 5, extern_alias_directives_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "extern_alias_directives"

    public class extern_alias_directive_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "extern_alias_directive"
    // G:\\downloads\\antlr\\cs.g:51:1: extern_alias_directive : 'extern' 'alias' identifier ';' ;
    public csParser.extern_alias_directive_return extern_alias_directive() // throws RecognitionException [1]
    {   
        csParser.extern_alias_directive_return retval = new csParser.extern_alias_directive_return();
        retval.Start = input.LT(1);
        int extern_alias_directive_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal14 = null;
        IToken string_literal15 = null;
        IToken char_literal17 = null;
        csParser.identifier_return identifier16 = default(csParser.identifier_return);


        object string_literal14_tree=null;
        object string_literal15_tree=null;
        object char_literal17_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 6) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:51:23: ( 'extern' 'alias' identifier ';' )
            // G:\\downloads\\antlr\\cs.g:52:2: 'extern' 'alias' identifier ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal14=(IToken)Match(input,64,FOLLOW_64_in_extern_alias_directive169); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal14_tree = (object)adaptor.Create(string_literal14);
            		adaptor.AddChild(root_0, string_literal14_tree);
            	}
            	string_literal15=(IToken)Match(input,65,FOLLOW_65_in_extern_alias_directive173); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal15_tree = (object)adaptor.Create(string_literal15);
            		adaptor.AddChild(root_0, string_literal15_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_extern_alias_directive177);
            	identifier16 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier16.Tree);
            	char_literal17=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_extern_alias_directive180); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal17_tree = (object)adaptor.Create(char_literal17);
            		adaptor.AddChild(root_0, char_literal17_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 6, extern_alias_directive_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "extern_alias_directive"

    public class using_directives_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "using_directives"
    // G:\\downloads\\antlr\\cs.g:53:1: using_directives : ( using_directive )+ ;
    public csParser.using_directives_return using_directives() // throws RecognitionException [1]
    {   
        csParser.using_directives_return retval = new csParser.using_directives_return();
        retval.Start = input.LT(1);
        int using_directives_StartIndex = input.Index();
        object root_0 = null;

        csParser.using_directive_return using_directive18 = default(csParser.using_directive_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 7) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:53:17: ( ( using_directive )+ )
            // G:\\downloads\\antlr\\cs.g:54:2: ( using_directive )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:54:2: ( using_directive )+
            	int cnt7 = 0;
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( (LA7_0 == USING) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:54:2: using_directive
            			    {
            			    	PushFollow(FOLLOW_using_directive_in_using_directives188);
            			    	using_directive18 = using_directive();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_directive18.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt7 >= 1 ) goto loop7;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(7, input);
            		            throw eee;
            	    }
            	    cnt7++;
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whinging that label 'loop7' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 7, using_directives_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "using_directives"

    public class using_directive_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "using_directive"
    // G:\\downloads\\antlr\\cs.g:55:1: using_directive : ( using_alias_directive | using_namespace_directive ) ;
    public csParser.using_directive_return using_directive() // throws RecognitionException [1]
    {   
        csParser.using_directive_return retval = new csParser.using_directive_return();
        retval.Start = input.LT(1);
        int using_directive_StartIndex = input.Index();
        object root_0 = null;

        csParser.using_alias_directive_return using_alias_directive19 = default(csParser.using_alias_directive_return);

        csParser.using_namespace_directive_return using_namespace_directive20 = default(csParser.using_namespace_directive_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 8) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:55:16: ( ( using_alias_directive | using_namespace_directive ) )
            // G:\\downloads\\antlr\\cs.g:56:2: ( using_alias_directive | using_namespace_directive )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:56:2: ( using_alias_directive | using_namespace_directive )
            	int alt8 = 2;
            	int LA8_0 = input.LA(1);

            	if ( (LA8_0 == USING) )
            	{
            	    int LA8_1 = input.LA(2);

            	    if ( (LA8_1 == IDENTIFIER || LA8_1 == 65 || (LA8_1 >= 132 && LA8_1 <= 133) || (LA8_1 >= 135 && LA8_1 <= 148) || (LA8_1 >= 150 && LA8_1 <= 152) || LA8_1 == 154 || (LA8_1 >= 157 && LA8_1 <= 159) || LA8_1 == 170 || (LA8_1 >= 177 && LA8_1 <= 178) || LA8_1 == 195 || LA8_1 == 202) )
            	    {
            	        int LA8_2 = input.LA(3);

            	        if ( (LA8_2 == DOT || LA8_2 == SEMI || LA8_2 == 84 || LA8_2 == 99) )
            	        {
            	            alt8 = 2;
            	        }
            	        else if ( (LA8_2 == 66) )
            	        {
            	            alt8 = 1;
            	        }
            	        else 
            	        {
            	            if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	            NoViableAltException nvae_d8s2 =
            	                new NoViableAltException("", 8, 2, input);

            	            throw nvae_d8s2;
            	        }
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        NoViableAltException nvae_d8s1 =
            	            new NoViableAltException("", 8, 1, input);

            	        throw nvae_d8s1;
            	    }
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d8s0 =
            	        new NoViableAltException("", 8, 0, input);

            	    throw nvae_d8s0;
            	}
            	switch (alt8) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:56:3: using_alias_directive
            	        {
            	        	PushFollow(FOLLOW_using_alias_directive_in_using_directive198);
            	        	using_alias_directive19 = using_alias_directive();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_alias_directive19.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:57:4: using_namespace_directive
            	        {
            	        	PushFollow(FOLLOW_using_namespace_directive_in_using_directive203);
            	        	using_namespace_directive20 = using_namespace_directive();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_namespace_directive20.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 8, using_directive_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "using_directive"

    public class using_alias_directive_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "using_alias_directive"
    // G:\\downloads\\antlr\\cs.g:58:1: using_alias_directive : 'using' identifier '=' namespace_or_type_name ';' ;
    public csParser.using_alias_directive_return using_alias_directive() // throws RecognitionException [1]
    {   
        csParser.using_alias_directive_return retval = new csParser.using_alias_directive_return();
        retval.Start = input.LT(1);
        int using_alias_directive_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal21 = null;
        IToken char_literal23 = null;
        IToken char_literal25 = null;
        csParser.identifier_return identifier22 = default(csParser.identifier_return);

        csParser.namespace_or_type_name_return namespace_or_type_name24 = default(csParser.namespace_or_type_name_return);


        object string_literal21_tree=null;
        object char_literal23_tree=null;
        object char_literal25_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 9) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:58:22: ( 'using' identifier '=' namespace_or_type_name ';' )
            // G:\\downloads\\antlr\\cs.g:59:2: 'using' identifier '=' namespace_or_type_name ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal21=(IToken)Match(input,USING,FOLLOW_USING_in_using_alias_directive212); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal21_tree = (object)adaptor.Create(string_literal21);
            		adaptor.AddChild(root_0, string_literal21_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_using_alias_directive216);
            	identifier22 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier22.Tree);
            	char_literal23=(IToken)Match(input,66,FOLLOW_66_in_using_alias_directive220); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal23_tree = (object)adaptor.Create(char_literal23);
            		adaptor.AddChild(root_0, char_literal23_tree);
            	}
            	PushFollow(FOLLOW_namespace_or_type_name_in_using_alias_directive224);
            	namespace_or_type_name24 = namespace_or_type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_or_type_name24.Tree);
            	char_literal25=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_using_alias_directive228); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal25_tree = (object)adaptor.Create(char_literal25);
            		adaptor.AddChild(root_0, char_literal25_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 9, using_alias_directive_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "using_alias_directive"

    public class using_namespace_directive_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "using_namespace_directive"
    // G:\\downloads\\antlr\\cs.g:60:1: using_namespace_directive : 'using' namespace_name ';' ;
    public csParser.using_namespace_directive_return using_namespace_directive() // throws RecognitionException [1]
    {   
        csParser.using_namespace_directive_return retval = new csParser.using_namespace_directive_return();
        retval.Start = input.LT(1);
        int using_namespace_directive_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal26 = null;
        IToken char_literal28 = null;
        csParser.namespace_name_return namespace_name27 = default(csParser.namespace_name_return);


        object string_literal26_tree=null;
        object char_literal28_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 10) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:60:26: ( 'using' namespace_name ';' )
            // G:\\downloads\\antlr\\cs.g:61:2: 'using' namespace_name ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal26=(IToken)Match(input,USING,FOLLOW_USING_in_using_namespace_directive236); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal26_tree = (object)adaptor.Create(string_literal26);
            		adaptor.AddChild(root_0, string_literal26_tree);
            	}
            	PushFollow(FOLLOW_namespace_name_in_using_namespace_directive240);
            	namespace_name27 = namespace_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_name27.Tree);
            	char_literal28=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_using_namespace_directive244); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal28_tree = (object)adaptor.Create(char_literal28);
            		adaptor.AddChild(root_0, char_literal28_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 10, using_namespace_directive_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "using_namespace_directive"

    public class namespace_member_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "namespace_member_declarations"
    // G:\\downloads\\antlr\\cs.g:62:1: namespace_member_declarations : ( namespace_member_declaration )+ ;
    public csParser.namespace_member_declarations_return namespace_member_declarations() // throws RecognitionException [1]
    {   
        csParser.namespace_member_declarations_return retval = new csParser.namespace_member_declarations_return();
        retval.Start = input.LT(1);
        int namespace_member_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.namespace_member_declaration_return namespace_member_declaration29 = default(csParser.namespace_member_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 11) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:62:30: ( ( namespace_member_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:63:2: ( namespace_member_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:63:2: ( namespace_member_declaration )+
            	int cnt9 = 0;
            	do 
            	{
            	    int alt9 = 2;
            	    int LA9_0 = input.LA(1);

            	    if ( (LA9_0 == ENUM || LA9_0 == 61 || LA9_0 == 64 || (LA9_0 >= 67 && LA9_0 <= 80) || LA9_0 == 86 || LA9_0 == 97 || LA9_0 == 155 || LA9_0 == 169 || LA9_0 == 172) )
            	    {
            	        alt9 = 1;
            	    }


            	    switch (alt9) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:63:2: namespace_member_declaration
            			    {
            			    	PushFollow(FOLLOW_namespace_member_declaration_in_namespace_member_declarations252);
            			    	namespace_member_declaration29 = namespace_member_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_member_declaration29.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt9 >= 1 ) goto loop9;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(9, input);
            		            throw eee;
            	    }
            	    cnt9++;
            	} while (true);

            	loop9:
            		;	// Stops C# compiler whinging that label 'loop9' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 11, namespace_member_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "namespace_member_declarations"

    public class namespace_member_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "namespace_member_declaration"
    // G:\\downloads\\antlr\\cs.g:64:1: namespace_member_declaration : ( namespace_declaration | ( attributes )? ( modifiers )? type_declaration );
    public csParser.namespace_member_declaration_return namespace_member_declaration() // throws RecognitionException [1]
    {   
        csParser.namespace_member_declaration_return retval = new csParser.namespace_member_declaration_return();
        retval.Start = input.LT(1);
        int namespace_member_declaration_StartIndex = input.Index();
        object root_0 = null;

        csParser.namespace_declaration_return namespace_declaration30 = default(csParser.namespace_declaration_return);

        csParser.attributes_return attributes31 = default(csParser.attributes_return);

        csParser.modifiers_return modifiers32 = default(csParser.modifiers_return);

        csParser.type_declaration_return type_declaration33 = default(csParser.type_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 12) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:64:29: ( namespace_declaration | ( attributes )? ( modifiers )? type_declaration )
            int alt12 = 2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0 == 61) )
            {
                alt12 = 1;
            }
            else if ( (LA12_0 == ENUM || LA12_0 == 64 || (LA12_0 >= 67 && LA12_0 <= 80) || LA12_0 == 86 || LA12_0 == 97 || LA12_0 == 155 || LA12_0 == 169 || LA12_0 == 172) )
            {
                alt12 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d12s0 =
                    new NoViableAltException("", 12, 0, input);

                throw nvae_d12s0;
            }
            switch (alt12) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:65:2: namespace_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_namespace_declaration_in_namespace_member_declaration261);
                    	namespace_declaration30 = namespace_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_declaration30.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:66:4: ( attributes )? ( modifiers )? type_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:66:4: ( attributes )?
                    	int alt10 = 2;
                    	int LA10_0 = input.LA(1);

                    	if ( (LA10_0 == 86) )
                    	{
                    	    alt10 = 1;
                    	}
                    	switch (alt10) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:66:4: attributes
                    	        {
                    	        	PushFollow(FOLLOW_attributes_in_namespace_member_declaration266);
                    	        	attributes31 = attributes();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes31.Tree);

                    	        }
                    	        break;

                    	}

                    	// G:\\downloads\\antlr\\cs.g:66:18: ( modifiers )?
                    	int alt11 = 2;
                    	int LA11_0 = input.LA(1);

                    	if ( (LA11_0 == 64 || (LA11_0 >= 68 && LA11_0 <= 80)) )
                    	{
                    	    alt11 = 1;
                    	}
                    	switch (alt11) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:66:18: modifiers
                    	        {
                    	        	PushFollow(FOLLOW_modifiers_in_namespace_member_declaration271);
                    	        	modifiers32 = modifiers();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers32.Tree);

                    	        }
                    	        break;

                    	}

                    	PushFollow(FOLLOW_type_declaration_in_namespace_member_declaration276);
                    	type_declaration33 = type_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_declaration33.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 12, namespace_member_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "namespace_member_declaration"

    public class type_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_declaration"
    // G:\\downloads\\antlr\\cs.g:67:1: type_declaration : ( ( 'partial' )=> 'partial' ( class_declaration | struct_declaration | interface_declaration ) | class_declaration | struct_declaration | interface_declaration | enum_declaration | delegate_declaration );
    public csParser.type_declaration_return type_declaration() // throws RecognitionException [1]
    {   
        csParser.type_declaration_return retval = new csParser.type_declaration_return();
        retval.Start = input.LT(1);
        int type_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal34 = null;
        csParser.class_declaration_return class_declaration35 = default(csParser.class_declaration_return);

        csParser.struct_declaration_return struct_declaration36 = default(csParser.struct_declaration_return);

        csParser.interface_declaration_return interface_declaration37 = default(csParser.interface_declaration_return);

        csParser.class_declaration_return class_declaration38 = default(csParser.class_declaration_return);

        csParser.struct_declaration_return struct_declaration39 = default(csParser.struct_declaration_return);

        csParser.interface_declaration_return interface_declaration40 = default(csParser.interface_declaration_return);

        csParser.enum_declaration_return enum_declaration41 = default(csParser.enum_declaration_return);

        csParser.delegate_declaration_return delegate_declaration42 = default(csParser.delegate_declaration_return);


        object string_literal34_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 13) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:67:17: ( ( 'partial' )=> 'partial' ( class_declaration | struct_declaration | interface_declaration ) | class_declaration | struct_declaration | interface_declaration | enum_declaration | delegate_declaration )
            int alt14 = 6;
            int LA14_0 = input.LA(1);

            if ( (LA14_0 == 67) && (synpred1_cs()) )
            {
                alt14 = 1;
            }
            else if ( (LA14_0 == 155) )
            {
                alt14 = 2;
            }
            else if ( (LA14_0 == 169) )
            {
                alt14 = 3;
            }
            else if ( (LA14_0 == 172) )
            {
                alt14 = 4;
            }
            else if ( (LA14_0 == ENUM) )
            {
                alt14 = 5;
            }
            else if ( (LA14_0 == 97) )
            {
                alt14 = 6;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d14s0 =
                    new NoViableAltException("", 14, 0, input);

                throw nvae_d14s0;
            }
            switch (alt14) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:68:2: ( 'partial' )=> 'partial' ( class_declaration | struct_declaration | interface_declaration )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal34=(IToken)Match(input,67,FOLLOW_67_in_type_declaration290); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal34_tree = (object)adaptor.Create(string_literal34);
                    		adaptor.AddChild(root_0, string_literal34_tree);
                    	}
                    	// G:\\downloads\\antlr\\cs.g:68:29: ( class_declaration | struct_declaration | interface_declaration )
                    	int alt13 = 3;
                    	switch ( input.LA(1) ) 
                    	{
                    	case 155:
                    		{
                    	    alt13 = 1;
                    	    }
                    	    break;
                    	case 169:
                    		{
                    	    alt13 = 2;
                    	    }
                    	    break;
                    	case 172:
                    		{
                    	    alt13 = 3;
                    	    }
                    	    break;
                    		default:
                    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    		    NoViableAltException nvae_d13s0 =
                    		        new NoViableAltException("", 13, 0, input);

                    		    throw nvae_d13s0;
                    	}

                    	switch (alt13) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:68:30: class_declaration
                    	        {
                    	        	PushFollow(FOLLOW_class_declaration_in_type_declaration295);
                    	        	class_declaration35 = class_declaration();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration35.Tree);

                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:69:11: struct_declaration
                    	        {
                    	        	PushFollow(FOLLOW_struct_declaration_in_type_declaration307);
                    	        	struct_declaration36 = struct_declaration();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration36.Tree);

                    	        }
                    	        break;
                    	    case 3 :
                    	        // G:\\downloads\\antlr\\cs.g:70:11: interface_declaration
                    	        {
                    	        	PushFollow(FOLLOW_interface_declaration_in_type_declaration319);
                    	        	interface_declaration37 = interface_declaration();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration37.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:71:4: class_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_class_declaration_in_type_declaration325);
                    	class_declaration38 = class_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration38.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:72:4: struct_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_struct_declaration_in_type_declaration330);
                    	struct_declaration39 = struct_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration39.Tree);

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:73:4: interface_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_interface_declaration_in_type_declaration335);
                    	interface_declaration40 = interface_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration40.Tree);

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:74:4: enum_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_enum_declaration_in_type_declaration340);
                    	enum_declaration41 = enum_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_declaration41.Tree);

                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:75:4: delegate_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_delegate_declaration_in_type_declaration345);
                    	delegate_declaration42 = delegate_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration42.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 13, type_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_declaration"

    public class qualified_identifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "qualified_identifier"
    // G:\\downloads\\antlr\\cs.g:77:1: qualified_identifier : identifier ( '.' identifier )* ;
    public csParser.qualified_identifier_return qualified_identifier() // throws RecognitionException [1]
    {   
        csParser.qualified_identifier_return retval = new csParser.qualified_identifier_return();
        retval.Start = input.LT(1);
        int qualified_identifier_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal44 = null;
        csParser.identifier_return identifier43 = default(csParser.identifier_return);

        csParser.identifier_return identifier45 = default(csParser.identifier_return);


        object char_literal44_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 14) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:77:21: ( identifier ( '.' identifier )* )
            // G:\\downloads\\antlr\\cs.g:78:2: identifier ( '.' identifier )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_qualified_identifier354);
            	identifier43 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier43.Tree);
            	// G:\\downloads\\antlr\\cs.g:78:13: ( '.' identifier )*
            	do 
            	{
            	    int alt15 = 2;
            	    int LA15_0 = input.LA(1);

            	    if ( (LA15_0 == DOT) )
            	    {
            	        alt15 = 1;
            	    }


            	    switch (alt15) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:78:14: '.' identifier
            			    {
            			    	char_literal44=(IToken)Match(input,DOT,FOLLOW_DOT_in_qualified_identifier357); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal44_tree = (object)adaptor.Create(char_literal44);
            			    		adaptor.AddChild(root_0, char_literal44_tree);
            			    	}
            			    	PushFollow(FOLLOW_identifier_in_qualified_identifier359);
            			    	identifier45 = identifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier45.Tree);

            			    }
            			    break;

            			default:
            			    goto loop15;
            	    }
            	} while (true);

            	loop15:
            		;	// Stops C# compiler whining that label 'loop15' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 14, qualified_identifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "qualified_identifier"

    public class namespace_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "namespace_name"
    // G:\\downloads\\antlr\\cs.g:79:1: namespace_name : namespace_or_type_name ;
    public csParser.namespace_name_return namespace_name() // throws RecognitionException [1]
    {   
        csParser.namespace_name_return retval = new csParser.namespace_name_return();
        retval.Start = input.LT(1);
        int namespace_name_StartIndex = input.Index();
        object root_0 = null;

        csParser.namespace_or_type_name_return namespace_or_type_name46 = default(csParser.namespace_or_type_name_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 15) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:80:2: ( namespace_or_type_name )
            // G:\\downloads\\antlr\\cs.g:80:4: namespace_or_type_name
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_namespace_or_type_name_in_namespace_name370);
            	namespace_or_type_name46 = namespace_or_type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_or_type_name46.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 15, namespace_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "namespace_name"

    public class modifiers_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "modifiers"
    // G:\\downloads\\antlr\\cs.g:82:1: modifiers : ( modifier )+ ;
    public csParser.modifiers_return modifiers() // throws RecognitionException [1]
    {   
        csParser.modifiers_return retval = new csParser.modifiers_return();
        retval.Start = input.LT(1);
        int modifiers_StartIndex = input.Index();
        object root_0 = null;

        csParser.modifier_return modifier47 = default(csParser.modifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 16) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:82:10: ( ( modifier )+ )
            // G:\\downloads\\antlr\\cs.g:83:2: ( modifier )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:83:2: ( modifier )+
            	int cnt16 = 0;
            	do 
            	{
            	    int alt16 = 2;
            	    int LA16_0 = input.LA(1);

            	    if ( (LA16_0 == 64 || (LA16_0 >= 68 && LA16_0 <= 80)) )
            	    {
            	        alt16 = 1;
            	    }


            	    switch (alt16) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:83:2: modifier
            			    {
            			    	PushFollow(FOLLOW_modifier_in_modifiers379);
            			    	modifier47 = modifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier47.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt16 >= 1 ) goto loop16;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(16, input);
            		            throw eee;
            	    }
            	    cnt16++;
            	} while (true);

            	loop16:
            		;	// Stops C# compiler whinging that label 'loop16' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 16, modifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "modifiers"

    public class modifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "modifier"
    // G:\\downloads\\antlr\\cs.g:84:1: modifier : ( 'new' | 'public' | 'protected' | 'private' | 'internal' | 'unsafe' | 'abstract' | 'sealed' | 'static' | 'readonly' | 'volatile' | 'extern' | 'virtual' | 'override' );
    public csParser.modifier_return modifier() // throws RecognitionException [1]
    {   
        csParser.modifier_return retval = new csParser.modifier_return();
        retval.Start = input.LT(1);
        int modifier_StartIndex = input.Index();
        object root_0 = null;

        IToken set48 = null;

        object set48_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 17) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:84:9: ( 'new' | 'public' | 'protected' | 'private' | 'internal' | 'unsafe' | 'abstract' | 'sealed' | 'static' | 'readonly' | 'volatile' | 'extern' | 'virtual' | 'override' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set48 = (IToken)input.LT(1);
            	if ( input.LA(1) == 64 || (input.LA(1) >= 68 && input.LA(1) <= 80) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set48));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 17, modifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "modifier"

    public class class_member_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "class_member_declaration"
    // G:\\downloads\\antlr\\cs.g:88:1: class_member_declaration : ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration ) ;
    public csParser.class_member_declaration_return class_member_declaration() // throws RecognitionException [1]
    {   
        csParser.class_member_declaration_return retval = new csParser.class_member_declaration_return();
        retval.Start = input.LT(1);
        int class_member_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal50 = null;
        IToken char_literal53 = null;
        IToken string_literal55 = null;
        IToken string_literal61 = null;
        IToken char_literal67 = null;
        csParser.modifiers_return m = default(csParser.modifiers_return);

        csParser.attributes_return attributes49 = default(csParser.attributes_return);

        csParser.type_return type51 = default(csParser.type_return);

        csParser.constant_declarators_return constant_declarators52 = default(csParser.constant_declarators_return);

        csParser.event_declaration_return event_declaration54 = default(csParser.event_declaration_return);

        csParser.method_declaration_return method_declaration56 = default(csParser.method_declaration_return);

        csParser.interface_declaration_return interface_declaration57 = default(csParser.interface_declaration_return);

        csParser.class_declaration_return class_declaration58 = default(csParser.class_declaration_return);

        csParser.struct_declaration_return struct_declaration59 = default(csParser.struct_declaration_return);

        csParser.interface_declaration_return interface_declaration60 = default(csParser.interface_declaration_return);

        csParser.method_declaration_return method_declaration62 = default(csParser.method_declaration_return);

        csParser.type_return type63 = default(csParser.type_return);

        csParser.method_declaration_return method_declaration64 = default(csParser.method_declaration_return);

        csParser.property_declaration_return property_declaration65 = default(csParser.property_declaration_return);

        csParser.type_name_return type_name66 = default(csParser.type_name_return);

        csParser.indexer_declaration_return indexer_declaration68 = default(csParser.indexer_declaration_return);

        csParser.indexer_declaration_return indexer_declaration69 = default(csParser.indexer_declaration_return);

        csParser.field_declaration_return field_declaration70 = default(csParser.field_declaration_return);

        csParser.operator_declaration_return operator_declaration71 = default(csParser.operator_declaration_return);

        csParser.class_declaration_return class_declaration72 = default(csParser.class_declaration_return);

        csParser.struct_declaration_return struct_declaration73 = default(csParser.struct_declaration_return);

        csParser.enum_declaration_return enum_declaration74 = default(csParser.enum_declaration_return);

        csParser.delegate_declaration_return delegate_declaration75 = default(csParser.delegate_declaration_return);

        csParser.conversion_operator_declaration_return conversion_operator_declaration76 = default(csParser.conversion_operator_declaration_return);

        csParser.constructor_declaration_return constructor_declaration77 = default(csParser.constructor_declaration_return);

        csParser.destructor_declaration_return destructor_declaration78 = default(csParser.destructor_declaration_return);


        object string_literal50_tree=null;
        object char_literal53_tree=null;
        object string_literal55_tree=null;
        object string_literal61_tree=null;
        object char_literal67_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 18) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:88:25: ( ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration ) )
            // G:\\downloads\\antlr\\cs.g:89:2: ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:89:2: ( attributes )?
            	int alt17 = 2;
            	int LA17_0 = input.LA(1);

            	if ( (LA17_0 == 86) )
            	{
            	    alt17 = 1;
            	}
            	switch (alt17) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:89:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_class_member_declaration451);
            	        	attributes49 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes49.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:90:3: (m= modifiers )?
            	int alt18 = 2;
            	int LA18_0 = input.LA(1);

            	if ( (LA18_0 == 64 || (LA18_0 >= 68 && LA18_0 <= 80)) )
            	{
            	    alt18 = 1;
            	}
            	switch (alt18) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:90:3: m= modifiers
            	        {
            	        	PushFollow(FOLLOW_modifiers_in_class_member_declaration457);
            	        	m = modifiers();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, m.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:91:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration )
            	int alt21 = 13;
            	alt21 = dfa21.Predict(input);
            	switch (alt21) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:91:4: 'const' type constant_declarators ';'
            	        {
            	        	string_literal50=(IToken)Match(input,81,FOLLOW_81_in_class_member_declaration463); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal50_tree = (object)adaptor.Create(string_literal50);
            	        		adaptor.AddChild(root_0, string_literal50_tree);
            	        	}
            	        	PushFollow(FOLLOW_type_in_class_member_declaration467);
            	        	type51 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type51.Tree);
            	        	PushFollow(FOLLOW_constant_declarators_in_class_member_declaration471);
            	        	constant_declarators52 = constant_declarators();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators52.Tree);
            	        	char_literal53=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_class_member_declaration475); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal53_tree = (object)adaptor.Create(char_literal53);
            	        		adaptor.AddChild(root_0, char_literal53_tree);
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:92:4: event_declaration
            	        {
            	        	PushFollow(FOLLOW_event_declaration_in_class_member_declaration480);
            	        	event_declaration54 = event_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, event_declaration54.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // G:\\downloads\\antlr\\cs.g:93:4: 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration )
            	        {
            	        	string_literal55=(IToken)Match(input,67,FOLLOW_67_in_class_member_declaration487); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal55_tree = (object)adaptor.Create(string_literal55);
            	        		adaptor.AddChild(root_0, string_literal55_tree);
            	        	}
            	        	// G:\\downloads\\antlr\\cs.g:93:14: ( method_declaration | interface_declaration | class_declaration | struct_declaration )
            	        	int alt19 = 4;
            	        	switch ( input.LA(1) ) 
            	        	{
            	        	case IDENTIFIER:
            	        	case Real_literal:
            	        	case NUMBER:
            	        	case Hex_number:
            	        	case Character_literal:
            	        	case STRINGLITERAL:
            	        	case Verbatim_string_literal:
            	        	case TRUE:
            	        	case FALSE:
            	        	case NULL:
            	        	case 65:
            	        	case 132:
            	        	case 133:
            	        	case 135:
            	        	case 136:
            	        	case 137:
            	        	case 138:
            	        	case 139:
            	        	case 140:
            	        	case 141:
            	        	case 142:
            	        	case 143:
            	        	case 144:
            	        	case 145:
            	        	case 146:
            	        	case 147:
            	        	case 148:
            	        	case 150:
            	        	case 151:
            	        	case 152:
            	        	case 154:
            	        	case 157:
            	        	case 158:
            	        	case 159:
            	        	case 160:
            	        	case 161:
            	        	case 162:
            	        	case 163:
            	        	case 164:
            	        	case 165:
            	        	case 166:
            	        	case 167:
            	        	case 168:
            	        	case 170:
            	        	case 177:
            	        	case 178:
            	        	case 195:
            	        	case 196:
            	        	case 197:
            	        	case 198:
            	        	case 199:
            	        	case 200:
            	        	case 201:
            	        	case 202:
            	        		{
            	        	    alt19 = 1;
            	        	    }
            	        	    break;
            	        	case 172:
            	        		{
            	        	    alt19 = 2;
            	        	    }
            	        	    break;
            	        	case 155:
            	        		{
            	        	    alt19 = 3;
            	        	    }
            	        	    break;
            	        	case 169:
            	        		{
            	        	    alt19 = 4;
            	        	    }
            	        	    break;
            	        		default:
            	        		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        		    NoViableAltException nvae_d19s0 =
            	        		        new NoViableAltException("", 19, 0, input);

            	        		    throw nvae_d19s0;
            	        	}

            	        	switch (alt19) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:93:15: method_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_method_declaration_in_class_member_declaration490);
            	        	        	method_declaration56 = method_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration56.Tree);

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:94:9: interface_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_interface_declaration_in_class_member_declaration501);
            	        	        	interface_declaration57 = interface_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration57.Tree);

            	        	        }
            	        	        break;
            	        	    case 3 :
            	        	        // G:\\downloads\\antlr\\cs.g:95:9: class_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_class_declaration_in_class_member_declaration512);
            	        	        	class_declaration58 = class_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration58.Tree);

            	        	        }
            	        	        break;
            	        	    case 4 :
            	        	        // G:\\downloads\\antlr\\cs.g:96:9: struct_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_struct_declaration_in_class_member_declaration523);
            	        	        	struct_declaration59 = struct_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration59.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 4 :
            	        // G:\\downloads\\antlr\\cs.g:97:4: interface_declaration
            	        {
            	        	PushFollow(FOLLOW_interface_declaration_in_class_member_declaration529);
            	        	interface_declaration60 = interface_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration60.Tree);

            	        }
            	        break;
            	    case 5 :
            	        // G:\\downloads\\antlr\\cs.g:98:4: 'void' method_declaration
            	        {
            	        	string_literal61=(IToken)Match(input,82,FOLLOW_82_in_class_member_declaration535); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal61_tree = (object)adaptor.Create(string_literal61);
            	        		adaptor.AddChild(root_0, string_literal61_tree);
            	        	}
            	        	PushFollow(FOLLOW_method_declaration_in_class_member_declaration539);
            	        	method_declaration62 = method_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration62.Tree);

            	        }
            	        break;
            	    case 6 :
            	        // G:\\downloads\\antlr\\cs.g:99:4: type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
            	        {
            	        	PushFollow(FOLLOW_type_in_class_member_declaration544);
            	        	type63 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type63.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:99:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
            	        	int alt20 = 6;
            	        	alt20 = dfa20.Predict(input);
            	        	switch (alt20) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:99:11: ( member_name '(' )=> method_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_method_declaration_in_class_member_declaration558);
            	        	        	method_declaration64 = method_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration64.Tree);

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:100:8: ( member_name '{' )=> property_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_property_declaration_in_class_member_declaration577);
            	        	        	property_declaration65 = property_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, property_declaration65.Tree);

            	        	        }
            	        	        break;
            	        	    case 3 :
            	        	        // G:\\downloads\\antlr\\cs.g:101:8: ( member_name '.' 'this' )=> type_name '.' indexer_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_type_name_in_class_member_declaration600);
            	        	        	type_name66 = type_name();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name66.Tree);
            	        	        	char_literal67=(IToken)Match(input,DOT,FOLLOW_DOT_in_class_member_declaration602); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 )
            	        	        	{char_literal67_tree = (object)adaptor.Create(char_literal67);
            	        	        		adaptor.AddChild(root_0, char_literal67_tree);
            	        	        	}
            	        	        	PushFollow(FOLLOW_indexer_declaration_in_class_member_declaration604);
            	        	        	indexer_declaration68 = indexer_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration68.Tree);

            	        	        }
            	        	        break;
            	        	    case 4 :
            	        	        // G:\\downloads\\antlr\\cs.g:102:8: indexer_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_indexer_declaration_in_class_member_declaration613);
            	        	        	indexer_declaration69 = indexer_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration69.Tree);

            	        	        }
            	        	        break;
            	        	    case 5 :
            	        	        // G:\\downloads\\antlr\\cs.g:103:11: field_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_field_declaration_in_class_member_declaration626);
            	        	        	field_declaration70 = field_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, field_declaration70.Tree);

            	        	        }
            	        	        break;
            	        	    case 6 :
            	        	        // G:\\downloads\\antlr\\cs.g:104:11: operator_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_operator_declaration_in_class_member_declaration644);
            	        	        	operator_declaration71 = operator_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_declaration71.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 7 :
            	        // G:\\downloads\\antlr\\cs.g:108:4: class_declaration
            	        {
            	        	PushFollow(FOLLOW_class_declaration_in_class_member_declaration662);
            	        	class_declaration72 = class_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration72.Tree);

            	        }
            	        break;
            	    case 8 :
            	        // G:\\downloads\\antlr\\cs.g:109:4: struct_declaration
            	        {
            	        	PushFollow(FOLLOW_struct_declaration_in_class_member_declaration669);
            	        	struct_declaration73 = struct_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration73.Tree);

            	        }
            	        break;
            	    case 9 :
            	        // G:\\downloads\\antlr\\cs.g:110:4: enum_declaration
            	        {
            	        	PushFollow(FOLLOW_enum_declaration_in_class_member_declaration675);
            	        	enum_declaration74 = enum_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_declaration74.Tree);

            	        }
            	        break;
            	    case 10 :
            	        // G:\\downloads\\antlr\\cs.g:111:4: delegate_declaration
            	        {
            	        	PushFollow(FOLLOW_delegate_declaration_in_class_member_declaration682);
            	        	delegate_declaration75 = delegate_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration75.Tree);

            	        }
            	        break;
            	    case 11 :
            	        // G:\\downloads\\antlr\\cs.g:112:4: conversion_operator_declaration
            	        {
            	        	PushFollow(FOLLOW_conversion_operator_declaration_in_class_member_declaration688);
            	        	conversion_operator_declaration76 = conversion_operator_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conversion_operator_declaration76.Tree);

            	        }
            	        break;
            	    case 12 :
            	        // G:\\downloads\\antlr\\cs.g:113:4: constructor_declaration
            	        {
            	        	PushFollow(FOLLOW_constructor_declaration_in_class_member_declaration693);
            	        	constructor_declaration77 = constructor_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_declaration77.Tree);

            	        }
            	        break;
            	    case 13 :
            	        // G:\\downloads\\antlr\\cs.g:114:4: destructor_declaration
            	        {
            	        	PushFollow(FOLLOW_destructor_declaration_in_class_member_declaration699);
            	        	destructor_declaration78 = destructor_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, destructor_declaration78.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 18, class_member_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "class_member_declaration"

    public class primary_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "primary_expression"
    // G:\\downloads\\antlr\\cs.g:118:1: primary_expression : ( ( 'this' brackets )=> 'this' brackets ( primary_expression_part )* | ( 'base' brackets )=> 'this' brackets ( primary_expression_part )* | primary_expression_start ( primary_expression_part )* | 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression ) | sizeof_expression | checked_expression | unchecked_expression | default_value_expression | anonymous_method_expression );
    public csParser.primary_expression_return primary_expression() // throws RecognitionException [1]
    {   
        csParser.primary_expression_return retval = new csParser.primary_expression_return();
        retval.Start = input.LT(1);
        int primary_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal79 = null;
        IToken string_literal82 = null;
        IToken string_literal87 = null;
        csParser.brackets_return brackets80 = default(csParser.brackets_return);

        csParser.primary_expression_part_return primary_expression_part81 = default(csParser.primary_expression_part_return);

        csParser.brackets_return brackets83 = default(csParser.brackets_return);

        csParser.primary_expression_part_return primary_expression_part84 = default(csParser.primary_expression_part_return);

        csParser.primary_expression_start_return primary_expression_start85 = default(csParser.primary_expression_start_return);

        csParser.primary_expression_part_return primary_expression_part86 = default(csParser.primary_expression_part_return);

        csParser.object_creation_expression_return object_creation_expression88 = default(csParser.object_creation_expression_return);

        csParser.primary_expression_part_return primary_expression_part89 = default(csParser.primary_expression_part_return);

        csParser.delegate_creation_expression_return delegate_creation_expression90 = default(csParser.delegate_creation_expression_return);

        csParser.object_creation_expression_return object_creation_expression91 = default(csParser.object_creation_expression_return);

        csParser.anonymous_object_creation_expression_return anonymous_object_creation_expression92 = default(csParser.anonymous_object_creation_expression_return);

        csParser.sizeof_expression_return sizeof_expression93 = default(csParser.sizeof_expression_return);

        csParser.checked_expression_return checked_expression94 = default(csParser.checked_expression_return);

        csParser.unchecked_expression_return unchecked_expression95 = default(csParser.unchecked_expression_return);

        csParser.default_value_expression_return default_value_expression96 = default(csParser.default_value_expression_return);

        csParser.anonymous_method_expression_return anonymous_method_expression97 = default(csParser.anonymous_method_expression_return);


        object string_literal79_tree=null;
        object string_literal82_tree=null;
        object string_literal87_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 19) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:118:19: ( ( 'this' brackets )=> 'this' brackets ( primary_expression_part )* | ( 'base' brackets )=> 'this' brackets ( primary_expression_part )* | primary_expression_start ( primary_expression_part )* | 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression ) | sizeof_expression | checked_expression | unchecked_expression | default_value_expression | anonymous_method_expression )
            int alt27 = 9;
            alt27 = dfa27.Predict(input);
            switch (alt27) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:119:2: ( 'this' brackets )=> 'this' brackets ( primary_expression_part )*
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal79=(IToken)Match(input,83,FOLLOW_83_in_primary_expression725); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal79_tree = (object)adaptor.Create(string_literal79);
                    		adaptor.AddChild(root_0, string_literal79_tree);
                    	}
                    	PushFollow(FOLLOW_brackets_in_primary_expression729);
                    	brackets80 = brackets();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets80.Tree);
                    	// G:\\downloads\\antlr\\cs.g:119:46: ( primary_expression_part )*
                    	do 
                    	{
                    	    int alt22 = 2;
                    	    int LA22_0 = input.LA(1);

                    	    if ( ((LA22_0 >= DOT && LA22_0 <= PTR) || LA22_0 == 86 || LA22_0 == 88) )
                    	    {
                    	        alt22 = 1;
                    	    }


                    	    switch (alt22) 
                    		{
                    			case 1 :
                    			    // G:\\downloads\\antlr\\cs.g:119:46: primary_expression_part
                    			    {
                    			    	PushFollow(FOLLOW_primary_expression_part_in_primary_expression733);
                    			    	primary_expression_part81 = primary_expression_part();
                    			    	state.followingStackPointer--;
                    			    	if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part81.Tree);

                    			    }
                    			    break;

                    			default:
                    			    goto loop22;
                    	    }
                    	} while (true);

                    	loop22:
                    		;	// Stops C# compiler whining that label 'loop22' has no statements


                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:120:4: ( 'base' brackets )=> 'this' brackets ( primary_expression_part )*
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal82=(IToken)Match(input,83,FOLLOW_83_in_primary_expression749); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal82_tree = (object)adaptor.Create(string_literal82);
                    		adaptor.AddChild(root_0, string_literal82_tree);
                    	}
                    	PushFollow(FOLLOW_brackets_in_primary_expression753);
                    	brackets83 = brackets();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets83.Tree);
                    	// G:\\downloads\\antlr\\cs.g:120:47: ( primary_expression_part )*
                    	do 
                    	{
                    	    int alt23 = 2;
                    	    int LA23_0 = input.LA(1);

                    	    if ( ((LA23_0 >= DOT && LA23_0 <= PTR) || LA23_0 == 86 || LA23_0 == 88) )
                    	    {
                    	        alt23 = 1;
                    	    }


                    	    switch (alt23) 
                    		{
                    			case 1 :
                    			    // G:\\downloads\\antlr\\cs.g:120:47: primary_expression_part
                    			    {
                    			    	PushFollow(FOLLOW_primary_expression_part_in_primary_expression757);
                    			    	primary_expression_part84 = primary_expression_part();
                    			    	state.followingStackPointer--;
                    			    	if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part84.Tree);

                    			    }
                    			    break;

                    			default:
                    			    goto loop23;
                    	    }
                    	} while (true);

                    	loop23:
                    		;	// Stops C# compiler whining that label 'loop23' has no statements


                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:121:4: primary_expression_start ( primary_expression_part )*
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_primary_expression_start_in_primary_expression763);
                    	primary_expression_start85 = primary_expression_start();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_start85.Tree);
                    	// G:\\downloads\\antlr\\cs.g:121:31: ( primary_expression_part )*
                    	do 
                    	{
                    	    int alt24 = 2;
                    	    int LA24_0 = input.LA(1);

                    	    if ( ((LA24_0 >= DOT && LA24_0 <= PTR) || LA24_0 == 86 || LA24_0 == 88) )
                    	    {
                    	        alt24 = 1;
                    	    }


                    	    switch (alt24) 
                    		{
                    			case 1 :
                    			    // G:\\downloads\\antlr\\cs.g:121:31: primary_expression_part
                    			    {
                    			    	PushFollow(FOLLOW_primary_expression_part_in_primary_expression767);
                    			    	primary_expression_part86 = primary_expression_part();
                    			    	state.followingStackPointer--;
                    			    	if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part86.Tree);

                    			    }
                    			    break;

                    			default:
                    			    goto loop24;
                    	    }
                    	} while (true);

                    	loop24:
                    		;	// Stops C# compiler whining that label 'loop24' has no statements


                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:122:4: 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal87=(IToken)Match(input,68,FOLLOW_68_in_primary_expression773); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal87_tree = (object)adaptor.Create(string_literal87);
                    		adaptor.AddChild(root_0, string_literal87_tree);
                    	}
                    	// G:\\downloads\\antlr\\cs.g:122:10: ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression )
                    	int alt26 = 4;
                    	switch ( input.LA(1) ) 
                    	{
                    	case 160:
                    	case 161:
                    	case 162:
                    	case 163:
                    	case 164:
                    	case 165:
                    	case 166:
                    	case 167:
                    	case 168:
                    	case 196:
                    	case 197:
                    	case 198:
                    	case 199:
                    	case 200:
                    	case 201:
                    		{
                    	    int LA26_1 = input.LA(2);

                    	    if ( (synpred7_cs()) )
                    	    {
                    	        alt26 = 1;
                    	    }
                    	    else if ( (true) )
                    	    {
                    	        alt26 = 3;
                    	    }
                    	    else 
                    	    {
                    	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	        NoViableAltException nvae_d26s1 =
                    	            new NoViableAltException("", 26, 1, input);

                    	        throw nvae_d26s1;
                    	    }
                    	    }
                    	    break;
                    	case IDENTIFIER:
                    	case 65:
                    	case 132:
                    	case 133:
                    	case 135:
                    	case 136:
                    	case 137:
                    	case 138:
                    	case 139:
                    	case 140:
                    	case 141:
                    	case 142:
                    	case 143:
                    	case 144:
                    	case 145:
                    	case 146:
                    	case 147:
                    	case 148:
                    	case 150:
                    	case 151:
                    	case 152:
                    	case 154:
                    	case 157:
                    	case 158:
                    	case 159:
                    	case 170:
                    	case 177:
                    	case 178:
                    	case 195:
                    	case 202:
                    		{
                    	    int LA26_2 = input.LA(2);

                    	    if ( (synpred7_cs()) )
                    	    {
                    	        alt26 = 1;
                    	    }
                    	    else if ( (synpred8_cs()) )
                    	    {
                    	        alt26 = 2;
                    	    }
                    	    else if ( (true) )
                    	    {
                    	        alt26 = 3;
                    	    }
                    	    else 
                    	    {
                    	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	        NoViableAltException nvae_d26s2 =
                    	            new NoViableAltException("", 26, 2, input);

                    	        throw nvae_d26s2;
                    	    }
                    	    }
                    	    break;
                    	case 82:
                    		{
                    	    int LA26_3 = input.LA(2);

                    	    if ( (synpred7_cs()) )
                    	    {
                    	        alt26 = 1;
                    	    }
                    	    else if ( (true) )
                    	    {
                    	        alt26 = 3;
                    	    }
                    	    else 
                    	    {
                    	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	        NoViableAltException nvae_d26s3 =
                    	            new NoViableAltException("", 26, 3, input);

                    	        throw nvae_d26s3;
                    	    }
                    	    }
                    	    break;
                    	case 62:
                    		{
                    	    alt26 = 4;
                    	    }
                    	    break;
                    		default:
                    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    		    NoViableAltException nvae_d26s0 =
                    		        new NoViableAltException("", 26, 0, input);

                    		    throw nvae_d26s0;
                    	}

                    	switch (alt26) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:122:14: ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+
                    	        {
                    	        	PushFollow(FOLLOW_object_creation_expression_in_primary_expression801);
                    	        	object_creation_expression88 = object_creation_expression();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_creation_expression88.Tree);
                    	        	// G:\\downloads\\antlr\\cs.g:123:35: ( primary_expression_part )+
                    	        	int cnt25 = 0;
                    	        	do 
                    	        	{
                    	        	    int alt25 = 2;
                    	        	    int LA25_0 = input.LA(1);

                    	        	    if ( ((LA25_0 >= DOT && LA25_0 <= PTR) || LA25_0 == 86 || LA25_0 == 88) )
                    	        	    {
                    	        	        alt25 = 1;
                    	        	    }


                    	        	    switch (alt25) 
                    	        		{
                    	        			case 1 :
                    	        			    // G:\\downloads\\antlr\\cs.g:123:35: primary_expression_part
                    	        			    {
                    	        			    	PushFollow(FOLLOW_primary_expression_part_in_primary_expression805);
                    	        			    	primary_expression_part89 = primary_expression_part();
                    	        			    	state.followingStackPointer--;
                    	        			    	if (state.failed) return retval;
                    	        			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression_part89.Tree);

                    	        			    }
                    	        			    break;

                    	        			default:
                    	        			    if ( cnt25 >= 1 ) goto loop25;
                    	        			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	        		            EarlyExitException eee =
                    	        		                new EarlyExitException(25, input);
                    	        		            throw eee;
                    	        	    }
                    	        	    cnt25++;
                    	        	} while (true);

                    	        	loop25:
                    	        		;	// Stops C# compiler whinging that label 'loop25' has no statements


                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:126:7: ( delegate_creation_expression )=> delegate_creation_expression
                    	        {
                    	        	PushFollow(FOLLOW_delegate_creation_expression_in_primary_expression833);
                    	        	delegate_creation_expression90 = delegate_creation_expression();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_creation_expression90.Tree);

                    	        }
                    	        break;
                    	    case 3 :
                    	        // G:\\downloads\\antlr\\cs.g:127:7: object_creation_expression
                    	        {
                    	        	PushFollow(FOLLOW_object_creation_expression_in_primary_expression841);
                    	        	object_creation_expression91 = object_creation_expression();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_creation_expression91.Tree);

                    	        }
                    	        break;
                    	    case 4 :
                    	        // G:\\downloads\\antlr\\cs.g:128:7: anonymous_object_creation_expression
                    	        {
                    	        	PushFollow(FOLLOW_anonymous_object_creation_expression_in_primary_expression849);
                    	        	anonymous_object_creation_expression92 = anonymous_object_creation_expression();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_object_creation_expression92.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:129:4: sizeof_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_sizeof_expression_in_primary_expression862);
                    	sizeof_expression93 = sizeof_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, sizeof_expression93.Tree);

                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:130:4: checked_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_checked_expression_in_primary_expression873);
                    	checked_expression94 = checked_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, checked_expression94.Tree);

                    }
                    break;
                case 7 :
                    // G:\\downloads\\antlr\\cs.g:131:4: unchecked_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_unchecked_expression_in_primary_expression892);
                    	unchecked_expression95 = unchecked_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unchecked_expression95.Tree);

                    }
                    break;
                case 8 :
                    // G:\\downloads\\antlr\\cs.g:132:4: default_value_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_default_value_expression_in_primary_expression909);
                    	default_value_expression96 = default_value_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, default_value_expression96.Tree);

                    }
                    break;
                case 9 :
                    // G:\\downloads\\antlr\\cs.g:133:4: anonymous_method_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_anonymous_method_expression_in_primary_expression922);
                    	anonymous_method_expression97 = anonymous_method_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_method_expression97.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 19, primary_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primary_expression"

    public class primary_expression_start_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "primary_expression_start"
    // G:\\downloads\\antlr\\cs.g:136:1: primary_expression_start : ( predefined_type | ( identifier '<' )=> identifier generic_argument_list | identifier ( '::' identifier )? | 'this' | 'base' | paren_expression | typeof_expression | literal );
    public csParser.primary_expression_start_return primary_expression_start() // throws RecognitionException [1]
    {   
        csParser.primary_expression_start_return retval = new csParser.primary_expression_start_return();
        retval.Start = input.LT(1);
        int primary_expression_start_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal102 = null;
        IToken string_literal104 = null;
        IToken string_literal105 = null;
        csParser.predefined_type_return predefined_type98 = default(csParser.predefined_type_return);

        csParser.identifier_return identifier99 = default(csParser.identifier_return);

        csParser.generic_argument_list_return generic_argument_list100 = default(csParser.generic_argument_list_return);

        csParser.identifier_return identifier101 = default(csParser.identifier_return);

        csParser.identifier_return identifier103 = default(csParser.identifier_return);

        csParser.paren_expression_return paren_expression106 = default(csParser.paren_expression_return);

        csParser.typeof_expression_return typeof_expression107 = default(csParser.typeof_expression_return);

        csParser.literal_return literal108 = default(csParser.literal_return);


        object string_literal102_tree=null;
        object string_literal104_tree=null;
        object string_literal105_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 20) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:136:25: ( predefined_type | ( identifier '<' )=> identifier generic_argument_list | identifier ( '::' identifier )? | 'this' | 'base' | paren_expression | typeof_expression | literal )
            int alt29 = 8;
            alt29 = dfa29.Predict(input);
            switch (alt29) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:137:2: predefined_type
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_predefined_type_in_primary_expression_start935);
                    	predefined_type98 = predefined_type();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type98.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:138:4: ( identifier '<' )=> identifier generic_argument_list
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_primary_expression_start963);
                    	identifier99 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier99.Tree);
                    	PushFollow(FOLLOW_generic_argument_list_in_primary_expression_start967);
                    	generic_argument_list100 = generic_argument_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list100.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:139:4: identifier ( '::' identifier )?
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_primary_expression_start972);
                    	identifier101 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier101.Tree);
                    	// G:\\downloads\\antlr\\cs.g:139:15: ( '::' identifier )?
                    	int alt28 = 2;
                    	int LA28_0 = input.LA(1);

                    	if ( (LA28_0 == 84) )
                    	{
                    	    alt28 = 1;
                    	}
                    	switch (alt28) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:139:16: '::' identifier
                    	        {
                    	        	string_literal102=(IToken)Match(input,84,FOLLOW_84_in_primary_expression_start975); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{string_literal102_tree = (object)adaptor.Create(string_literal102);
                    	        		adaptor.AddChild(root_0, string_literal102_tree);
                    	        	}
                    	        	PushFollow(FOLLOW_identifier_in_primary_expression_start979);
                    	        	identifier103 = identifier();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier103.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:140:4: 'this'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal104=(IToken)Match(input,83,FOLLOW_83_in_primary_expression_start986); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal104_tree = (object)adaptor.Create(string_literal104);
                    		adaptor.AddChild(root_0, string_literal104_tree);
                    	}

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:141:4: 'base'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal105=(IToken)Match(input,85,FOLLOW_85_in_primary_expression_start992); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal105_tree = (object)adaptor.Create(string_literal105);
                    		adaptor.AddChild(root_0, string_literal105_tree);
                    	}

                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:142:4: paren_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_paren_expression_in_primary_expression_start997);
                    	paren_expression106 = paren_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, paren_expression106.Tree);

                    }
                    break;
                case 7 :
                    // G:\\downloads\\antlr\\cs.g:143:4: typeof_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_typeof_expression_in_primary_expression_start1002);
                    	typeof_expression107 = typeof_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, typeof_expression107.Tree);

                    }
                    break;
                case 8 :
                    // G:\\downloads\\antlr\\cs.g:144:4: literal
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_literal_in_primary_expression_start1020);
                    	literal108 = literal();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal108.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 20, primary_expression_start_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primary_expression_start"

    public class primary_expression_part_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "primary_expression_part"
    // G:\\downloads\\antlr\\cs.g:147:1: primary_expression_part : ( access_identifier | brackets_or_arguments );
    public csParser.primary_expression_part_return primary_expression_part() // throws RecognitionException [1]
    {   
        csParser.primary_expression_part_return retval = new csParser.primary_expression_part_return();
        retval.Start = input.LT(1);
        int primary_expression_part_StartIndex = input.Index();
        object root_0 = null;

        csParser.access_identifier_return access_identifier109 = default(csParser.access_identifier_return);

        csParser.brackets_or_arguments_return brackets_or_arguments110 = default(csParser.brackets_or_arguments_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 21) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:147:24: ( access_identifier | brackets_or_arguments )
            int alt30 = 2;
            int LA30_0 = input.LA(1);

            if ( ((LA30_0 >= DOT && LA30_0 <= PTR)) )
            {
                alt30 = 1;
            }
            else if ( (LA30_0 == 86 || LA30_0 == 88) )
            {
                alt30 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d30s0 =
                    new NoViableAltException("", 30, 0, input);

                throw nvae_d30s0;
            }
            switch (alt30) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:148:3: access_identifier
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_access_identifier_in_primary_expression_part1031);
                    	access_identifier109 = access_identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_identifier109.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:149:4: brackets_or_arguments
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_brackets_or_arguments_in_primary_expression_part1036);
                    	brackets_or_arguments110 = brackets_or_arguments();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets_or_arguments110.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 21, primary_expression_part_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primary_expression_part"

    public class access_identifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "access_identifier"
    // G:\\downloads\\antlr\\cs.g:150:1: access_identifier : access_operator type_or_generic ;
    public csParser.access_identifier_return access_identifier() // throws RecognitionException [1]
    {   
        csParser.access_identifier_return retval = new csParser.access_identifier_return();
        retval.Start = input.LT(1);
        int access_identifier_StartIndex = input.Index();
        object root_0 = null;

        csParser.access_operator_return access_operator111 = default(csParser.access_operator_return);

        csParser.type_or_generic_return type_or_generic112 = default(csParser.type_or_generic_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 22) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:150:18: ( access_operator type_or_generic )
            // G:\\downloads\\antlr\\cs.g:151:2: access_operator type_or_generic
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_access_operator_in_access_identifier1044);
            	access_operator111 = access_operator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_operator111.Tree);
            	PushFollow(FOLLOW_type_or_generic_in_access_identifier1048);
            	type_or_generic112 = type_or_generic();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic112.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 22, access_identifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "access_identifier"

    public class access_operator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "access_operator"
    // G:\\downloads\\antlr\\cs.g:152:1: access_operator : ( '.' | '->' );
    public csParser.access_operator_return access_operator() // throws RecognitionException [1]
    {   
        csParser.access_operator_return retval = new csParser.access_operator_return();
        retval.Start = input.LT(1);
        int access_operator_StartIndex = input.Index();
        object root_0 = null;

        IToken set113 = null;

        object set113_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 23) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:152:16: ( '.' | '->' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set113 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= DOT && input.LA(1) <= PTR) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set113));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 23, access_operator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "access_operator"

    public class brackets_or_arguments_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "brackets_or_arguments"
    // G:\\downloads\\antlr\\cs.g:154:1: brackets_or_arguments : ( brackets | arguments );
    public csParser.brackets_or_arguments_return brackets_or_arguments() // throws RecognitionException [1]
    {   
        csParser.brackets_or_arguments_return retval = new csParser.brackets_or_arguments_return();
        retval.Start = input.LT(1);
        int brackets_or_arguments_StartIndex = input.Index();
        object root_0 = null;

        csParser.brackets_return brackets114 = default(csParser.brackets_return);

        csParser.arguments_return arguments115 = default(csParser.arguments_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 24) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:154:22: ( brackets | arguments )
            int alt31 = 2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0 == 86) )
            {
                alt31 = 1;
            }
            else if ( (LA31_0 == 88) )
            {
                alt31 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d31s0 =
                    new NoViableAltException("", 31, 0, input);

                throw nvae_d31s0;
            }
            switch (alt31) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:155:2: brackets
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_brackets_in_brackets_or_arguments1070);
                    	brackets114 = brackets();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets114.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:155:13: arguments
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_arguments_in_brackets_or_arguments1074);
                    	arguments115 = arguments();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments115.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 24, brackets_or_arguments_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "brackets_or_arguments"

    public class brackets_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "brackets"
    // G:\\downloads\\antlr\\cs.g:156:1: brackets : '[' ( expression_list )? ']' ;
    public csParser.brackets_return brackets() // throws RecognitionException [1]
    {   
        csParser.brackets_return retval = new csParser.brackets_return();
        retval.Start = input.LT(1);
        int brackets_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal116 = null;
        IToken char_literal118 = null;
        csParser.expression_list_return expression_list117 = default(csParser.expression_list_return);


        object char_literal116_tree=null;
        object char_literal118_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 25) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:156:9: ( '[' ( expression_list )? ']' )
            // G:\\downloads\\antlr\\cs.g:157:2: '[' ( expression_list )? ']'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal116=(IToken)Match(input,86,FOLLOW_86_in_brackets1082); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal116_tree = (object)adaptor.Create(char_literal116);
            		adaptor.AddChild(root_0, char_literal116_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:157:8: ( expression_list )?
            	int alt32 = 2;
            	int LA32_0 = input.LA(1);

            	if ( ((LA32_0 >= IDENTIFIER && LA32_0 <= NULL) || LA32_0 == MINUS || LA32_0 == 65 || LA32_0 == 68 || LA32_0 == 83 || LA32_0 == 85 || LA32_0 == 88 || (LA32_0 >= 93 && LA32_0 <= 98) || LA32_0 == 100 || (LA32_0 >= 102 && LA32_0 <= 106) || LA32_0 == 117 || (LA32_0 >= 132 && LA32_0 <= 133) || (LA32_0 >= 135 && LA32_0 <= 148) || (LA32_0 >= 150 && LA32_0 <= 152) || LA32_0 == 154 || (LA32_0 >= 157 && LA32_0 <= 168) || LA32_0 == 170 || (LA32_0 >= 177 && LA32_0 <= 178) || (LA32_0 >= 195 && LA32_0 <= 202)) )
            	{
            	    alt32 = 1;
            	}
            	switch (alt32) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:157:8: expression_list
            	        {
            	        	PushFollow(FOLLOW_expression_list_in_brackets1086);
            	        	expression_list117 = expression_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_list117.Tree);

            	        }
            	        break;

            	}

            	char_literal118=(IToken)Match(input,87,FOLLOW_87_in_brackets1091); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal118_tree = (object)adaptor.Create(char_literal118);
            		adaptor.AddChild(root_0, char_literal118_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 25, brackets_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "brackets"

    public class paren_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "paren_expression"
    // G:\\downloads\\antlr\\cs.g:158:1: paren_expression : '(' expression ')' ;
    public csParser.paren_expression_return paren_expression() // throws RecognitionException [1]
    {   
        csParser.paren_expression_return retval = new csParser.paren_expression_return();
        retval.Start = input.LT(1);
        int paren_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal119 = null;
        IToken char_literal121 = null;
        csParser.expression_return expression120 = default(csParser.expression_return);


        object char_literal119_tree=null;
        object char_literal121_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 26) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:158:17: ( '(' expression ')' )
            // G:\\downloads\\antlr\\cs.g:159:2: '(' expression ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal119=(IToken)Match(input,88,FOLLOW_88_in_paren_expression1101); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal119_tree = (object)adaptor.Create(char_literal119);
            		adaptor.AddChild(root_0, char_literal119_tree);
            	}
            	PushFollow(FOLLOW_expression_in_paren_expression1105);
            	expression120 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression120.Tree);
            	char_literal121=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_paren_expression1109); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal121_tree = (object)adaptor.Create(char_literal121);
            		adaptor.AddChild(root_0, char_literal121_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 26, paren_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "paren_expression"

    public class arguments_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "arguments"
    // G:\\downloads\\antlr\\cs.g:160:1: arguments : '(' ( argument_list )? ')' ;
    public csParser.arguments_return arguments() // throws RecognitionException [1]
    {   
        csParser.arguments_return retval = new csParser.arguments_return();
        retval.Start = input.LT(1);
        int arguments_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal122 = null;
        IToken char_literal124 = null;
        csParser.argument_list_return argument_list123 = default(csParser.argument_list_return);


        object char_literal122_tree=null;
        object char_literal124_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 27) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:160:10: ( '(' ( argument_list )? ')' )
            // G:\\downloads\\antlr\\cs.g:161:2: '(' ( argument_list )? ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal122=(IToken)Match(input,88,FOLLOW_88_in_arguments1118); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal122_tree = (object)adaptor.Create(char_literal122);
            		adaptor.AddChild(root_0, char_literal122_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:161:8: ( argument_list )?
            	int alt33 = 2;
            	int LA33_0 = input.LA(1);

            	if ( ((LA33_0 >= IDENTIFIER && LA33_0 <= NULL) || LA33_0 == MINUS || LA33_0 == 65 || LA33_0 == 68 || LA33_0 == 83 || LA33_0 == 85 || LA33_0 == 88 || (LA33_0 >= 91 && LA33_0 <= 98) || LA33_0 == 100 || (LA33_0 >= 102 && LA33_0 <= 106) || LA33_0 == 117 || (LA33_0 >= 132 && LA33_0 <= 133) || (LA33_0 >= 135 && LA33_0 <= 148) || (LA33_0 >= 150 && LA33_0 <= 152) || LA33_0 == 154 || (LA33_0 >= 157 && LA33_0 <= 168) || LA33_0 == 170 || (LA33_0 >= 177 && LA33_0 <= 178) || (LA33_0 >= 195 && LA33_0 <= 202)) )
            	{
            	    alt33 = 1;
            	}
            	switch (alt33) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:161:8: argument_list
            	        {
            	        	PushFollow(FOLLOW_argument_list_in_arguments1122);
            	        	argument_list123 = argument_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_list123.Tree);

            	        }
            	        break;

            	}

            	char_literal124=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_arguments1127); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal124_tree = (object)adaptor.Create(char_literal124);
            		adaptor.AddChild(root_0, char_literal124_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 27, arguments_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "arguments"

    public class argument_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "argument_list"
    // G:\\downloads\\antlr\\cs.g:162:1: argument_list : argument ( ',' argument )* ;
    public csParser.argument_list_return argument_list() // throws RecognitionException [1]
    {   
        csParser.argument_list_return retval = new csParser.argument_list_return();
        retval.Start = input.LT(1);
        int argument_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal126 = null;
        csParser.argument_return argument125 = default(csParser.argument_return);

        csParser.argument_return argument127 = default(csParser.argument_return);


        object char_literal126_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 28) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:162:14: ( argument ( ',' argument )* )
            // G:\\downloads\\antlr\\cs.g:163:2: argument ( ',' argument )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_argument_in_argument_list1136);
            	argument125 = argument();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument125.Tree);
            	// G:\\downloads\\antlr\\cs.g:163:11: ( ',' argument )*
            	do 
            	{
            	    int alt34 = 2;
            	    int LA34_0 = input.LA(1);

            	    if ( (LA34_0 == 89) )
            	    {
            	        alt34 = 1;
            	    }


            	    switch (alt34) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:163:12: ',' argument
            			    {
            			    	char_literal126=(IToken)Match(input,89,FOLLOW_89_in_argument_list1139); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal126_tree = (object)adaptor.Create(char_literal126);
            			    		adaptor.AddChild(root_0, char_literal126_tree);
            			    	}
            			    	PushFollow(FOLLOW_argument_in_argument_list1141);
            			    	argument127 = argument();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument127.Tree);

            			    }
            			    break;

            			default:
            			    goto loop34;
            	    }
            	} while (true);

            	loop34:
            		;	// Stops C# compiler whining that label 'loop34' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 28, argument_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "argument_list"

    public class argument_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "argument"
    // G:\\downloads\\antlr\\cs.g:165:1: argument : ( argument_name argument_value | argument_value );
    public csParser.argument_return argument() // throws RecognitionException [1]
    {   
        csParser.argument_return retval = new csParser.argument_return();
        retval.Start = input.LT(1);
        int argument_StartIndex = input.Index();
        object root_0 = null;

        csParser.argument_name_return argument_name128 = default(csParser.argument_name_return);

        csParser.argument_value_return argument_value129 = default(csParser.argument_value_return);

        csParser.argument_value_return argument_value130 = default(csParser.argument_value_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 29) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:165:9: ( argument_name argument_value | argument_value )
            int alt35 = 2;
            switch ( input.LA(1) ) 
            {
            case 133:
            	{
                int LA35_1 = input.LA(2);

                if ( (LA35_1 == IDENTIFIER || (LA35_1 >= DOT && LA35_1 <= GT) || LA35_1 == RPAREN || (LA35_1 >= 65 && LA35_1 <= 66) || LA35_1 == 82 || LA35_1 == 84 || LA35_1 == 86 || (LA35_1 >= 88 && LA35_1 <= 89) || (LA35_1 >= 99 && LA35_1 <= 104) || (LA35_1 >= 107 && LA35_1 <= 133) || (LA35_1 >= 135 && LA35_1 <= 148) || (LA35_1 >= 150 && LA35_1 <= 152) || LA35_1 == 154 || (LA35_1 >= 157 && LA35_1 <= 168) || LA35_1 == 170 || (LA35_1 >= 177 && LA35_1 <= 178) || (LA35_1 >= 195 && LA35_1 <= 202)) )
                {
                    alt35 = 2;
                }
                else if ( (LA35_1 == 90) )
                {
                    alt35 = 1;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d35s1 =
                        new NoViableAltException("", 35, 1, input);

                    throw nvae_d35s1;
                }
                }
                break;
            case Real_literal:
            case NUMBER:
            case Hex_number:
            case Character_literal:
            case STRINGLITERAL:
            case Verbatim_string_literal:
            case TRUE:
            case FALSE:
            case NULL:
            case MINUS:
            case 68:
            case 83:
            case 85:
            case 88:
            case 91:
            case 92:
            case 93:
            case 94:
            case 95:
            case 96:
            case 97:
            case 98:
            case 100:
            case 102:
            case 103:
            case 104:
            case 105:
            case 106:
            case 117:
            case 160:
            case 161:
            case 162:
            case 163:
            case 164:
            case 165:
            case 166:
            case 167:
            case 168:
            case 196:
            case 197:
            case 198:
            case 199:
            case 200:
            case 201:
            	{
                alt35 = 2;
                }
                break;
            case IDENTIFIER:
            case 65:
            case 132:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 170:
            case 177:
            case 178:
            case 195:
            case 202:
            	{
                int LA35_3 = input.LA(2);

                if ( ((LA35_3 >= DOT && LA35_3 <= GT) || LA35_3 == RPAREN || LA35_3 == 66 || LA35_3 == 84 || LA35_3 == 86 || (LA35_3 >= 88 && LA35_3 <= 89) || (LA35_3 >= 99 && LA35_3 <= 104) || (LA35_3 >= 107 && LA35_3 <= 131)) )
                {
                    alt35 = 2;
                }
                else if ( (LA35_3 == 90) )
                {
                    alt35 = 1;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d35s3 =
                        new NoViableAltException("", 35, 3, input);

                    throw nvae_d35s3;
                }
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d35s0 =
            	        new NoViableAltException("", 35, 0, input);

            	    throw nvae_d35s0;
            }

            switch (alt35) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:166:2: argument_name argument_value
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_argument_name_in_argument1151);
                    	argument_name128 = argument_name();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_name128.Tree);
                    	PushFollow(FOLLOW_argument_value_in_argument1155);
                    	argument_value129 = argument_value();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_value129.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:167:4: argument_value
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_argument_value_in_argument1160);
                    	argument_value130 = argument_value();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_value130.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 29, argument_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "argument"

    public class argument_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "argument_name"
    // G:\\downloads\\antlr\\cs.g:168:1: argument_name : identifier ':' ;
    public csParser.argument_name_return argument_name() // throws RecognitionException [1]
    {   
        csParser.argument_name_return retval = new csParser.argument_name_return();
        retval.Start = input.LT(1);
        int argument_name_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal132 = null;
        csParser.identifier_return identifier131 = default(csParser.identifier_return);


        object char_literal132_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 30) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:168:14: ( identifier ':' )
            // G:\\downloads\\antlr\\cs.g:169:2: identifier ':'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_argument_name1167);
            	identifier131 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier131.Tree);
            	char_literal132=(IToken)Match(input,90,FOLLOW_90_in_argument_name1171); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal132_tree = (object)adaptor.Create(char_literal132);
            		adaptor.AddChild(root_0, char_literal132_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 30, argument_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "argument_name"

    public class argument_value_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "argument_value"
    // G:\\downloads\\antlr\\cs.g:170:1: argument_value : ( expression | ref_variable_reference | 'out' variable_reference );
    public csParser.argument_value_return argument_value() // throws RecognitionException [1]
    {   
        csParser.argument_value_return retval = new csParser.argument_value_return();
        retval.Start = input.LT(1);
        int argument_value_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal135 = null;
        csParser.expression_return expression133 = default(csParser.expression_return);

        csParser.ref_variable_reference_return ref_variable_reference134 = default(csParser.ref_variable_reference_return);

        csParser.variable_reference_return variable_reference136 = default(csParser.variable_reference_return);


        object string_literal135_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 31) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:170:15: ( expression | ref_variable_reference | 'out' variable_reference )
            int alt36 = 3;
            switch ( input.LA(1) ) 
            {
            case IDENTIFIER:
            case Real_literal:
            case NUMBER:
            case Hex_number:
            case Character_literal:
            case STRINGLITERAL:
            case Verbatim_string_literal:
            case TRUE:
            case FALSE:
            case NULL:
            case MINUS:
            case 65:
            case 68:
            case 83:
            case 85:
            case 88:
            case 93:
            case 94:
            case 95:
            case 96:
            case 97:
            case 98:
            case 100:
            case 102:
            case 103:
            case 104:
            case 105:
            case 106:
            case 117:
            case 132:
            case 133:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 160:
            case 161:
            case 162:
            case 163:
            case 164:
            case 165:
            case 166:
            case 167:
            case 168:
            case 170:
            case 177:
            case 178:
            case 195:
            case 196:
            case 197:
            case 198:
            case 199:
            case 200:
            case 201:
            case 202:
            	{
                alt36 = 1;
                }
                break;
            case 92:
            	{
                alt36 = 2;
                }
                break;
            case 91:
            	{
                alt36 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d36s0 =
            	        new NoViableAltException("", 36, 0, input);

            	    throw nvae_d36s0;
            }

            switch (alt36) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:171:2: expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_in_argument_value1179);
                    	expression133 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression133.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:172:4: ref_variable_reference
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_ref_variable_reference_in_argument_value1185);
                    	ref_variable_reference134 = ref_variable_reference();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ref_variable_reference134.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:173:4: 'out' variable_reference
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal135=(IToken)Match(input,91,FOLLOW_91_in_argument_value1191); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal135_tree = (object)adaptor.Create(string_literal135);
                    		adaptor.AddChild(root_0, string_literal135_tree);
                    	}
                    	PushFollow(FOLLOW_variable_reference_in_argument_value1195);
                    	variable_reference136 = variable_reference();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_reference136.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 31, argument_value_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "argument_value"

    public class ref_variable_reference_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "ref_variable_reference"
    // G:\\downloads\\antlr\\cs.g:174:1: ref_variable_reference : 'ref' ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference ) ;
    public csParser.ref_variable_reference_return ref_variable_reference() // throws RecognitionException [1]
    {   
        csParser.ref_variable_reference_return retval = new csParser.ref_variable_reference_return();
        retval.Start = input.LT(1);
        int ref_variable_reference_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal137 = null;
        IToken char_literal138 = null;
        IToken char_literal140 = null;
        csParser.type_return type139 = default(csParser.type_return);

        csParser.ref_variable_reference_return ref_variable_reference141 = default(csParser.ref_variable_reference_return);

        csParser.variable_reference_return variable_reference142 = default(csParser.variable_reference_return);

        csParser.variable_reference_return variable_reference143 = default(csParser.variable_reference_return);


        object string_literal137_tree=null;
        object char_literal138_tree=null;
        object char_literal140_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 32) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:174:23: ( 'ref' ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference ) )
            // G:\\downloads\\antlr\\cs.g:175:2: 'ref' ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal137=(IToken)Match(input,92,FOLLOW_92_in_ref_variable_reference1203); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal137_tree = (object)adaptor.Create(string_literal137);
            		adaptor.AddChild(root_0, string_literal137_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:176:3: ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference )
            	int alt38 = 2;
            	alt38 = dfa38.Predict(input);
            	switch (alt38) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:176:4: ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference )
            	        {
            	        	char_literal138=(IToken)Match(input,88,FOLLOW_88_in_ref_variable_reference1225); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal138_tree = (object)adaptor.Create(char_literal138);
            	        		adaptor.AddChild(root_0, char_literal138_tree);
            	        	}
            	        	PushFollow(FOLLOW_type_in_ref_variable_reference1229);
            	        	type139 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type139.Tree);
            	        	char_literal140=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_ref_variable_reference1233); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal140_tree = (object)adaptor.Create(char_literal140);
            	        		adaptor.AddChild(root_0, char_literal140_tree);
            	        	}
            	        	// G:\\downloads\\antlr\\cs.g:176:47: ( ref_variable_reference | variable_reference )
            	        	int alt37 = 2;
            	        	int LA37_0 = input.LA(1);

            	        	if ( (LA37_0 == 92) )
            	        	{
            	        	    alt37 = 1;
            	        	}
            	        	else if ( ((LA37_0 >= IDENTIFIER && LA37_0 <= NULL) || LA37_0 == MINUS || LA37_0 == 65 || LA37_0 == 68 || LA37_0 == 83 || LA37_0 == 85 || LA37_0 == 88 || (LA37_0 >= 93 && LA37_0 <= 98) || LA37_0 == 100 || (LA37_0 >= 102 && LA37_0 <= 106) || LA37_0 == 117 || (LA37_0 >= 132 && LA37_0 <= 133) || (LA37_0 >= 135 && LA37_0 <= 148) || (LA37_0 >= 150 && LA37_0 <= 152) || LA37_0 == 154 || (LA37_0 >= 157 && LA37_0 <= 168) || LA37_0 == 170 || (LA37_0 >= 177 && LA37_0 <= 178) || (LA37_0 >= 195 && LA37_0 <= 202)) )
            	        	{
            	        	    alt37 = 2;
            	        	}
            	        	else 
            	        	{
            	        	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        	    NoViableAltException nvae_d37s0 =
            	        	        new NoViableAltException("", 37, 0, input);

            	        	    throw nvae_d37s0;
            	        	}
            	        	switch (alt37) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:176:48: ref_variable_reference
            	        	        {
            	        	        	PushFollow(FOLLOW_ref_variable_reference_in_ref_variable_reference1238);
            	        	        	ref_variable_reference141 = ref_variable_reference();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ref_variable_reference141.Tree);

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:176:73: variable_reference
            	        	        {
            	        	        	PushFollow(FOLLOW_variable_reference_in_ref_variable_reference1242);
            	        	        	variable_reference142 = variable_reference();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_reference142.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:178:5: variable_reference
            	        {
            	        	PushFollow(FOLLOW_variable_reference_in_ref_variable_reference1278);
            	        	variable_reference143 = variable_reference();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_reference143.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 32, ref_variable_reference_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "ref_variable_reference"

    public class variable_reference_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variable_reference"
    // G:\\downloads\\antlr\\cs.g:180:1: variable_reference : expression ;
    public csParser.variable_reference_return variable_reference() // throws RecognitionException [1]
    {   
        csParser.variable_reference_return retval = new csParser.variable_reference_return();
        retval.Start = input.LT(1);
        int variable_reference_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression144 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 33) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:180:19: ( expression )
            // G:\\downloads\\antlr\\cs.g:181:2: expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_variable_reference1288);
            	expression144 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression144.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 33, variable_reference_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variable_reference"

    public class rank_specifiers_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "rank_specifiers"
    // G:\\downloads\\antlr\\cs.g:182:1: rank_specifiers : ( rank_specifier )+ ;
    public csParser.rank_specifiers_return rank_specifiers() // throws RecognitionException [1]
    {   
        csParser.rank_specifiers_return retval = new csParser.rank_specifiers_return();
        retval.Start = input.LT(1);
        int rank_specifiers_StartIndex = input.Index();
        object root_0 = null;

        csParser.rank_specifier_return rank_specifier145 = default(csParser.rank_specifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 34) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:182:16: ( ( rank_specifier )+ )
            // G:\\downloads\\antlr\\cs.g:183:2: ( rank_specifier )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:183:2: ( rank_specifier )+
            	int cnt39 = 0;
            	do 
            	{
            	    int alt39 = 2;
            	    int LA39_0 = input.LA(1);

            	    if ( (LA39_0 == 86) )
            	    {
            	        int LA39_2 = input.LA(2);

            	        if ( (LA39_2 == 87 || LA39_2 == 89) )
            	        {
            	            alt39 = 1;
            	        }


            	    }


            	    switch (alt39) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:183:2: rank_specifier
            			    {
            			    	PushFollow(FOLLOW_rank_specifier_in_rank_specifiers1296);
            			    	rank_specifier145 = rank_specifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifier145.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt39 >= 1 ) goto loop39;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(39, input);
            		            throw eee;
            	    }
            	    cnt39++;
            	} while (true);

            	loop39:
            		;	// Stops C# compiler whinging that label 'loop39' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 34, rank_specifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "rank_specifiers"

    public class rank_specifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "rank_specifier"
    // G:\\downloads\\antlr\\cs.g:184:1: rank_specifier : '[' ( dim_separators )? ']' ;
    public csParser.rank_specifier_return rank_specifier() // throws RecognitionException [1]
    {   
        csParser.rank_specifier_return retval = new csParser.rank_specifier_return();
        retval.Start = input.LT(1);
        int rank_specifier_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal146 = null;
        IToken char_literal148 = null;
        csParser.dim_separators_return dim_separators147 = default(csParser.dim_separators_return);


        object char_literal146_tree=null;
        object char_literal148_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 35) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:184:15: ( '[' ( dim_separators )? ']' )
            // G:\\downloads\\antlr\\cs.g:185:2: '[' ( dim_separators )? ']'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal146=(IToken)Match(input,86,FOLLOW_86_in_rank_specifier1314); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal146_tree = (object)adaptor.Create(char_literal146);
            		adaptor.AddChild(root_0, char_literal146_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:185:8: ( dim_separators )?
            	int alt40 = 2;
            	int LA40_0 = input.LA(1);

            	if ( (LA40_0 == 89) )
            	{
            	    alt40 = 1;
            	}
            	switch (alt40) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:185:8: dim_separators
            	        {
            	        	PushFollow(FOLLOW_dim_separators_in_rank_specifier1318);
            	        	dim_separators147 = dim_separators();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, dim_separators147.Tree);

            	        }
            	        break;

            	}

            	char_literal148=(IToken)Match(input,87,FOLLOW_87_in_rank_specifier1323); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal148_tree = (object)adaptor.Create(char_literal148);
            		adaptor.AddChild(root_0, char_literal148_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 35, rank_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "rank_specifier"

    public class dim_separators_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "dim_separators"
    // G:\\downloads\\antlr\\cs.g:186:1: dim_separators : ( ',' )+ ;
    public csParser.dim_separators_return dim_separators() // throws RecognitionException [1]
    {   
        csParser.dim_separators_return retval = new csParser.dim_separators_return();
        retval.Start = input.LT(1);
        int dim_separators_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal149 = null;

        object char_literal149_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 36) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:186:15: ( ( ',' )+ )
            // G:\\downloads\\antlr\\cs.g:187:2: ( ',' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:187:2: ( ',' )+
            	int cnt41 = 0;
            	do 
            	{
            	    int alt41 = 2;
            	    int LA41_0 = input.LA(1);

            	    if ( (LA41_0 == 89) )
            	    {
            	        alt41 = 1;
            	    }


            	    switch (alt41) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:187:2: ','
            			    {
            			    	char_literal149=(IToken)Match(input,89,FOLLOW_89_in_dim_separators1332); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal149_tree = (object)adaptor.Create(char_literal149);
            			    		adaptor.AddChild(root_0, char_literal149_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt41 >= 1 ) goto loop41;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(41, input);
            		            throw eee;
            	    }
            	    cnt41++;
            	} while (true);

            	loop41:
            		;	// Stops C# compiler whinging that label 'loop41' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 36, dim_separators_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "dim_separators"

    public class delegate_creation_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "delegate_creation_expression"
    // G:\\downloads\\antlr\\cs.g:189:1: delegate_creation_expression : type_name '(' type_name ')' ;
    public csParser.delegate_creation_expression_return delegate_creation_expression() // throws RecognitionException [1]
    {   
        csParser.delegate_creation_expression_return retval = new csParser.delegate_creation_expression_return();
        retval.Start = input.LT(1);
        int delegate_creation_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal151 = null;
        IToken char_literal153 = null;
        csParser.type_name_return type_name150 = default(csParser.type_name_return);

        csParser.type_name_return type_name152 = default(csParser.type_name_return);


        object char_literal151_tree=null;
        object char_literal153_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 37) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:189:29: ( type_name '(' type_name ')' )
            // G:\\downloads\\antlr\\cs.g:191:2: type_name '(' type_name ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_name_in_delegate_creation_expression1345);
            	type_name150 = type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name150.Tree);
            	char_literal151=(IToken)Match(input,88,FOLLOW_88_in_delegate_creation_expression1349); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal151_tree = (object)adaptor.Create(char_literal151);
            		adaptor.AddChild(root_0, char_literal151_tree);
            	}
            	PushFollow(FOLLOW_type_name_in_delegate_creation_expression1353);
            	type_name152 = type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name152.Tree);
            	char_literal153=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_delegate_creation_expression1357); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal153_tree = (object)adaptor.Create(char_literal153);
            		adaptor.AddChild(root_0, char_literal153_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 37, delegate_creation_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "delegate_creation_expression"

    public class anonymous_object_creation_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "anonymous_object_creation_expression"
    // G:\\downloads\\antlr\\cs.g:192:1: anonymous_object_creation_expression : anonymous_object_initializer ;
    public csParser.anonymous_object_creation_expression_return anonymous_object_creation_expression() // throws RecognitionException [1]
    {   
        csParser.anonymous_object_creation_expression_return retval = new csParser.anonymous_object_creation_expression_return();
        retval.Start = input.LT(1);
        int anonymous_object_creation_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.anonymous_object_initializer_return anonymous_object_initializer154 = default(csParser.anonymous_object_initializer_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 38) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:192:37: ( anonymous_object_initializer )
            // G:\\downloads\\antlr\\cs.g:194:2: anonymous_object_initializer
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_anonymous_object_initializer_in_anonymous_object_creation_expression1368);
            	anonymous_object_initializer154 = anonymous_object_initializer();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_object_initializer154.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 38, anonymous_object_creation_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "anonymous_object_creation_expression"

    public class anonymous_object_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "anonymous_object_initializer"
    // G:\\downloads\\antlr\\cs.g:195:1: anonymous_object_initializer : '{' ( member_declarator_list )? ( ',' )? '}' ;
    public csParser.anonymous_object_initializer_return anonymous_object_initializer() // throws RecognitionException [1]
    {   
        csParser.anonymous_object_initializer_return retval = new csParser.anonymous_object_initializer_return();
        retval.Start = input.LT(1);
        int anonymous_object_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal155 = null;
        IToken char_literal157 = null;
        IToken char_literal158 = null;
        csParser.member_declarator_list_return member_declarator_list156 = default(csParser.member_declarator_list_return);


        object char_literal155_tree=null;
        object char_literal157_tree=null;
        object char_literal158_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 39) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:195:29: ( '{' ( member_declarator_list )? ( ',' )? '}' )
            // G:\\downloads\\antlr\\cs.g:196:2: '{' ( member_declarator_list )? ( ',' )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal155=(IToken)Match(input,62,FOLLOW_62_in_anonymous_object_initializer1377); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal155_tree = (object)adaptor.Create(char_literal155);
            		adaptor.AddChild(root_0, char_literal155_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:196:8: ( member_declarator_list )?
            	int alt42 = 2;
            	int LA42_0 = input.LA(1);

            	if ( (LA42_0 == IDENTIFIER || LA42_0 == 65 || (LA42_0 >= 132 && LA42_0 <= 133) || (LA42_0 >= 135 && LA42_0 <= 148) || (LA42_0 >= 150 && LA42_0 <= 152) || LA42_0 == 154 || (LA42_0 >= 157 && LA42_0 <= 159) || LA42_0 == 170 || (LA42_0 >= 177 && LA42_0 <= 178) || LA42_0 == 195 || LA42_0 == 202) )
            	{
            	    alt42 = 1;
            	}
            	switch (alt42) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:196:8: member_declarator_list
            	        {
            	        	PushFollow(FOLLOW_member_declarator_list_in_anonymous_object_initializer1381);
            	        	member_declarator_list156 = member_declarator_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_declarator_list156.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:196:34: ( ',' )?
            	int alt43 = 2;
            	int LA43_0 = input.LA(1);

            	if ( (LA43_0 == 89) )
            	{
            	    alt43 = 1;
            	}
            	switch (alt43) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:196:34: ','
            	        {
            	        	char_literal157=(IToken)Match(input,89,FOLLOW_89_in_anonymous_object_initializer1386); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal157_tree = (object)adaptor.Create(char_literal157);
            	        		adaptor.AddChild(root_0, char_literal157_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal158=(IToken)Match(input,63,FOLLOW_63_in_anonymous_object_initializer1391); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal158_tree = (object)adaptor.Create(char_literal158);
            		adaptor.AddChild(root_0, char_literal158_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 39, anonymous_object_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "anonymous_object_initializer"

    public class member_declarator_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "member_declarator_list"
    // G:\\downloads\\antlr\\cs.g:197:1: member_declarator_list : member_declarator ( ',' member_declarator )* ;
    public csParser.member_declarator_list_return member_declarator_list() // throws RecognitionException [1]
    {   
        csParser.member_declarator_list_return retval = new csParser.member_declarator_list_return();
        retval.Start = input.LT(1);
        int member_declarator_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal160 = null;
        csParser.member_declarator_return member_declarator159 = default(csParser.member_declarator_return);

        csParser.member_declarator_return member_declarator161 = default(csParser.member_declarator_return);


        object char_literal160_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 40) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:197:23: ( member_declarator ( ',' member_declarator )* )
            // G:\\downloads\\antlr\\cs.g:198:2: member_declarator ( ',' member_declarator )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_member_declarator_in_member_declarator_list1399);
            	member_declarator159 = member_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_declarator159.Tree);
            	// G:\\downloads\\antlr\\cs.g:198:21: ( ',' member_declarator )*
            	do 
            	{
            	    int alt44 = 2;
            	    int LA44_0 = input.LA(1);

            	    if ( (LA44_0 == 89) )
            	    {
            	        int LA44_1 = input.LA(2);

            	        if ( (LA44_1 == IDENTIFIER || LA44_1 == 65 || (LA44_1 >= 132 && LA44_1 <= 133) || (LA44_1 >= 135 && LA44_1 <= 148) || (LA44_1 >= 150 && LA44_1 <= 152) || LA44_1 == 154 || (LA44_1 >= 157 && LA44_1 <= 159) || LA44_1 == 170 || (LA44_1 >= 177 && LA44_1 <= 178) || LA44_1 == 195 || LA44_1 == 202) )
            	        {
            	            alt44 = 1;
            	        }


            	    }


            	    switch (alt44) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:198:22: ',' member_declarator
            			    {
            			    	char_literal160=(IToken)Match(input,89,FOLLOW_89_in_member_declarator_list1403); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal160_tree = (object)adaptor.Create(char_literal160);
            			    		adaptor.AddChild(root_0, char_literal160_tree);
            			    	}
            			    	PushFollow(FOLLOW_member_declarator_in_member_declarator_list1405);
            			    	member_declarator161 = member_declarator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_declarator161.Tree);

            			    }
            			    break;

            			default:
            			    goto loop44;
            	    }
            	} while (true);

            	loop44:
            		;	// Stops C# compiler whining that label 'loop44' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 40, member_declarator_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "member_declarator_list"

    public class member_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "member_declarator"
    // G:\\downloads\\antlr\\cs.g:199:1: member_declarator : identifier ( generic_argument_list | ( '.' primary_or_array_creation_expression ) | '=' expression ) ;
    public csParser.member_declarator_return member_declarator() // throws RecognitionException [1]
    {   
        csParser.member_declarator_return retval = new csParser.member_declarator_return();
        retval.Start = input.LT(1);
        int member_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal164 = null;
        IToken char_literal166 = null;
        csParser.identifier_return identifier162 = default(csParser.identifier_return);

        csParser.generic_argument_list_return generic_argument_list163 = default(csParser.generic_argument_list_return);

        csParser.primary_or_array_creation_expression_return primary_or_array_creation_expression165 = default(csParser.primary_or_array_creation_expression_return);

        csParser.expression_return expression167 = default(csParser.expression_return);


        object char_literal164_tree=null;
        object char_literal166_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 41) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:199:18: ( identifier ( generic_argument_list | ( '.' primary_or_array_creation_expression ) | '=' expression ) )
            // G:\\downloads\\antlr\\cs.g:200:2: identifier ( generic_argument_list | ( '.' primary_or_array_creation_expression ) | '=' expression )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_member_declarator1417);
            	identifier162 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier162.Tree);
            	// G:\\downloads\\antlr\\cs.g:200:15: ( generic_argument_list | ( '.' primary_or_array_creation_expression ) | '=' expression )
            	int alt45 = 3;
            	switch ( input.LA(1) ) 
            	{
            	case 99:
            		{
            	    alt45 = 1;
            	    }
            	    break;
            	case DOT:
            		{
            	    alt45 = 2;
            	    }
            	    break;
            	case 66:
            		{
            	    alt45 = 3;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		    NoViableAltException nvae_d45s0 =
            		        new NoViableAltException("", 45, 0, input);

            		    throw nvae_d45s0;
            	}

            	switch (alt45) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:200:16: generic_argument_list
            	        {
            	        	PushFollow(FOLLOW_generic_argument_list_in_member_declarator1422);
            	        	generic_argument_list163 = generic_argument_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list163.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:201:8: ( '.' primary_or_array_creation_expression )
            	        {
            	        	// G:\\downloads\\antlr\\cs.g:201:8: ( '.' primary_or_array_creation_expression )
            	        	// G:\\downloads\\antlr\\cs.g:201:9: '.' primary_or_array_creation_expression
            	        	{
            	        		char_literal164=(IToken)Match(input,DOT,FOLLOW_DOT_in_member_declarator1432); if (state.failed) return retval;
            	        		if ( state.backtracking == 0 )
            	        		{char_literal164_tree = (object)adaptor.Create(char_literal164);
            	        			adaptor.AddChild(root_0, char_literal164_tree);
            	        		}
            	        		PushFollow(FOLLOW_primary_or_array_creation_expression_in_member_declarator1436);
            	        		primary_or_array_creation_expression165 = primary_or_array_creation_expression();
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_or_array_creation_expression165.Tree);

            	        	}


            	        }
            	        break;
            	    case 3 :
            	        // G:\\downloads\\antlr\\cs.g:202:8: '=' expression
            	        {
            	        	char_literal166=(IToken)Match(input,66,FOLLOW_66_in_member_declarator1446); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal166_tree = (object)adaptor.Create(char_literal166);
            	        		adaptor.AddChild(root_0, char_literal166_tree);
            	        	}
            	        	PushFollow(FOLLOW_expression_in_member_declarator1450);
            	        	expression167 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression167.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 41, member_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "member_declarator"

    public class primary_or_array_creation_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "primary_or_array_creation_expression"
    // G:\\downloads\\antlr\\cs.g:203:1: primary_or_array_creation_expression : ( ( array_creation_expression )=> array_creation_expression | primary_expression );
    public csParser.primary_or_array_creation_expression_return primary_or_array_creation_expression() // throws RecognitionException [1]
    {   
        csParser.primary_or_array_creation_expression_return retval = new csParser.primary_or_array_creation_expression_return();
        retval.Start = input.LT(1);
        int primary_or_array_creation_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.array_creation_expression_return array_creation_expression168 = default(csParser.array_creation_expression_return);

        csParser.primary_expression_return primary_expression169 = default(csParser.primary_expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 42) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:203:37: ( ( array_creation_expression )=> array_creation_expression | primary_expression )
            int alt46 = 2;
            alt46 = dfa46.Predict(input);
            switch (alt46) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:204:2: ( array_creation_expression )=> array_creation_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_array_creation_expression_in_primary_or_array_creation_expression1465);
                    	array_creation_expression168 = array_creation_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_creation_expression168.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:205:4: primary_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_primary_expression_in_primary_or_array_creation_expression1470);
                    	primary_expression169 = primary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression169.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 42, primary_or_array_creation_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primary_or_array_creation_expression"

    public class array_creation_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "array_creation_expression"
    // G:\\downloads\\antlr\\cs.g:208:1: array_creation_expression : 'new' ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) ) ;
    public csParser.array_creation_expression_return array_creation_expression() // throws RecognitionException [1]
    {   
        csParser.array_creation_expression_return retval = new csParser.array_creation_expression_return();
        retval.Start = input.LT(1);
        int array_creation_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal170 = null;
        IToken char_literal172 = null;
        IToken char_literal174 = null;
        csParser.type_return type171 = default(csParser.type_return);

        csParser.expression_list_return expression_list173 = default(csParser.expression_list_return);

        csParser.rank_specifiers_return rank_specifiers175 = default(csParser.rank_specifiers_return);

        csParser.array_initializer_return array_initializer176 = default(csParser.array_initializer_return);

        csParser.arguments_return arguments177 = default(csParser.arguments_return);

        csParser.invocation_part_return invocation_part178 = default(csParser.invocation_part_return);

        csParser.invocation_part_return invocation_part179 = default(csParser.invocation_part_return);

        csParser.arguments_return arguments180 = default(csParser.arguments_return);

        csParser.array_initializer_return array_initializer181 = default(csParser.array_initializer_return);

        csParser.rank_specifier_return rank_specifier182 = default(csParser.rank_specifier_return);

        csParser.array_initializer_return array_initializer183 = default(csParser.array_initializer_return);


        object string_literal170_tree=null;
        object char_literal172_tree=null;
        object char_literal174_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 43) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:208:26: ( 'new' ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) ) )
            // G:\\downloads\\antlr\\cs.g:209:2: 'new' ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal170=(IToken)Match(input,68,FOLLOW_68_in_array_creation_expression1481); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal170_tree = (object)adaptor.Create(string_literal170);
            		adaptor.AddChild(root_0, string_literal170_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:210:3: ( type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer ) | rank_specifier ( array_initializer ) )
            	int alt52 = 2;
            	int LA52_0 = input.LA(1);

            	if ( (LA52_0 == IDENTIFIER || LA52_0 == 65 || LA52_0 == 82 || (LA52_0 >= 132 && LA52_0 <= 133) || (LA52_0 >= 135 && LA52_0 <= 148) || (LA52_0 >= 150 && LA52_0 <= 152) || LA52_0 == 154 || (LA52_0 >= 157 && LA52_0 <= 168) || LA52_0 == 170 || (LA52_0 >= 177 && LA52_0 <= 178) || (LA52_0 >= 195 && LA52_0 <= 202)) )
            	{
            	    alt52 = 1;
            	}
            	else if ( (LA52_0 == 86) )
            	{
            	    alt52 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d52s0 =
            	        new NoViableAltException("", 52, 0, input);

            	    throw nvae_d52s0;
            	}
            	switch (alt52) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:210:4: type ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer )
            	        {
            	        	PushFollow(FOLLOW_type_in_array_creation_expression1489);
            	        	type171 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type171.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:210:11: ( '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ) | array_initializer )
            	        	int alt51 = 2;
            	        	int LA51_0 = input.LA(1);

            	        	if ( (LA51_0 == 86) )
            	        	{
            	        	    alt51 = 1;
            	        	}
            	        	else if ( (LA51_0 == 62) )
            	        	{
            	        	    alt51 = 2;
            	        	}
            	        	else 
            	        	{
            	        	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        	    NoViableAltException nvae_d51s0 =
            	        	        new NoViableAltException("", 51, 0, input);

            	        	    throw nvae_d51s0;
            	        	}
            	        	switch (alt51) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:210:12: '[' expression_list ']' ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )
            	        	        {
            	        	        	char_literal172=(IToken)Match(input,86,FOLLOW_86_in_array_creation_expression1494); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 )
            	        	        	{char_literal172_tree = (object)adaptor.Create(char_literal172);
            	        	        		adaptor.AddChild(root_0, char_literal172_tree);
            	        	        	}
            	        	        	PushFollow(FOLLOW_expression_list_in_array_creation_expression1498);
            	        	        	expression_list173 = expression_list();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_list173.Tree);
            	        	        	char_literal174=(IToken)Match(input,87,FOLLOW_87_in_array_creation_expression1502); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 )
            	        	        	{char_literal174_tree = (object)adaptor.Create(char_literal174);
            	        	        		adaptor.AddChild(root_0, char_literal174_tree);
            	        	        	}
            	        	        	// G:\\downloads\\antlr\\cs.g:211:6: ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )
            	        	        	int alt50 = 2;
            	        	        	alt50 = dfa50.Predict(input);
            	        	        	switch (alt50) 
            	        	        	{
            	        	        	    case 1 :
            	        	        	        // G:\\downloads\\antlr\\cs.g:211:8: ( rank_specifiers )? ( array_initializer )?
            	        	        	        {
            	        	        	        	// G:\\downloads\\antlr\\cs.g:211:8: ( rank_specifiers )?
            	        	        	        	int alt47 = 2;
            	        	        	        	int LA47_0 = input.LA(1);

            	        	        	        	if ( (LA47_0 == 86) )
            	        	        	        	{
            	        	        	        	    alt47 = 1;
            	        	        	        	}
            	        	        	        	switch (alt47) 
            	        	        	        	{
            	        	        	        	    case 1 :
            	        	        	        	        // G:\\downloads\\antlr\\cs.g:211:8: rank_specifiers
            	        	        	        	        {
            	        	        	        	        	PushFollow(FOLLOW_rank_specifiers_in_array_creation_expression1514);
            	        	        	        	        	rank_specifiers175 = rank_specifiers();
            	        	        	        	        	state.followingStackPointer--;
            	        	        	        	        	if (state.failed) return retval;
            	        	        	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifiers175.Tree);

            	        	        	        	        }
            	        	        	        	        break;

            	        	        	        	}

            	        	        	        	// G:\\downloads\\antlr\\cs.g:211:27: ( array_initializer )?
            	        	        	        	int alt48 = 2;
            	        	        	        	int LA48_0 = input.LA(1);

            	        	        	        	if ( (LA48_0 == 62) )
            	        	        	        	{
            	        	        	        	    alt48 = 1;
            	        	        	        	}
            	        	        	        	switch (alt48) 
            	        	        	        	{
            	        	        	        	    case 1 :
            	        	        	        	        // G:\\downloads\\antlr\\cs.g:211:27: array_initializer
            	        	        	        	        {
            	        	        	        	        	PushFollow(FOLLOW_array_initializer_in_array_creation_expression1519);
            	        	        	        	        	array_initializer176 = array_initializer();
            	        	        	        	        	state.followingStackPointer--;
            	        	        	        	        	if (state.failed) return retval;
            	        	        	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer176.Tree);

            	        	        	        	        }
            	        	        	        	        break;

            	        	        	        	}


            	        	        	        }
            	        	        	        break;
            	        	        	    case 2 :
            	        	        	        // G:\\downloads\\antlr\\cs.g:213:8: ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments
            	        	        	        {
            	        	        	        	// G:\\downloads\\antlr\\cs.g:213:8: ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )*
            	        	        	        	do 
            	        	        	        	{
            	        	        	        	    int alt49 = 3;
            	        	        	        	    int LA49_0 = input.LA(1);

            	        	        	        	    if ( (LA49_0 == 88) )
            	        	        	        	    {
            	        	        	        	        int LA49_1 = input.LA(2);

            	        	        	        	        if ( (synpred12_cs()) )
            	        	        	        	        {
            	        	        	        	            alt49 = 1;
            	        	        	        	        }


            	        	        	        	    }
            	        	        	        	    else if ( ((LA49_0 >= DOT && LA49_0 <= PTR) || LA49_0 == 86) )
            	        	        	        	    {
            	        	        	        	        alt49 = 2;
            	        	        	        	    }


            	        	        	        	    switch (alt49) 
            	        	        	        		{
            	        	        	        			case 1 :
            	        	        	        			    // G:\\downloads\\antlr\\cs.g:213:10: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
            	        	        	        			    {
            	        	        	        			    	// G:\\downloads\\antlr\\cs.g:213:10: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
            	        	        	        			    	// G:\\downloads\\antlr\\cs.g:213:11: ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part
            	        	        	        			    	{
            	        	        	        			    		PushFollow(FOLLOW_arguments_in_array_creation_expression1555);
            	        	        	        			    		arguments177 = arguments();
            	        	        	        			    		state.followingStackPointer--;
            	        	        	        			    		if (state.failed) return retval;
            	        	        	        			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments177.Tree);
            	        	        	        			    		PushFollow(FOLLOW_invocation_part_in_array_creation_expression1559);
            	        	        	        			    		invocation_part178 = invocation_part();
            	        	        	        			    		state.followingStackPointer--;
            	        	        	        			    		if (state.failed) return retval;
            	        	        	        			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part178.Tree);

            	        	        	        			    	}


            	        	        	        			    }
            	        	        	        			    break;
            	        	        	        			case 2 :
            	        	        	        			    // G:\\downloads\\antlr\\cs.g:214:10: invocation_part
            	        	        	        			    {
            	        	        	        			    	PushFollow(FOLLOW_invocation_part_in_array_creation_expression1571);
            	        	        	        			    	invocation_part179 = invocation_part();
            	        	        	        			    	state.followingStackPointer--;
            	        	        	        			    	if (state.failed) return retval;
            	        	        	        			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part179.Tree);

            	        	        	        			    }
            	        	        	        			    break;

            	        	        	        			default:
            	        	        	        			    goto loop49;
            	        	        	        	    }
            	        	        	        	} while (true);

            	        	        	        	loop49:
            	        	        	        		;	// Stops C# compiler whining that label 'loop49' has no statements

            	        	        	        	PushFollow(FOLLOW_arguments_in_array_creation_expression1577);
            	        	        	        	arguments180 = arguments();
            	        	        	        	state.followingStackPointer--;
            	        	        	        	if (state.failed) return retval;
            	        	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments180.Tree);

            	        	        	        }
            	        	        	        break;

            	        	        	}


            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:216:7: array_initializer
            	        	        {
            	        	        	PushFollow(FOLLOW_array_initializer_in_array_creation_expression1599);
            	        	        	array_initializer181 = array_initializer();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer181.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:218:5: rank_specifier ( array_initializer )
            	        {
            	        	PushFollow(FOLLOW_rank_specifier_in_array_creation_expression1613);
            	        	rank_specifier182 = rank_specifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifier182.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:219:4: ( array_initializer )
            	        	// G:\\downloads\\antlr\\cs.g:219:5: array_initializer
            	        	{
            	        		PushFollow(FOLLOW_array_initializer_in_array_creation_expression1622);
            	        		array_initializer183 = array_initializer();
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer183.Tree);

            	        	}


            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 43, array_creation_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "array_creation_expression"

    public class array_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "array_initializer"
    // G:\\downloads\\antlr\\cs.g:222:1: array_initializer : '{' ( variable_initializer_list )? ( ',' )? '}' ;
    public csParser.array_initializer_return array_initializer() // throws RecognitionException [1]
    {   
        csParser.array_initializer_return retval = new csParser.array_initializer_return();
        retval.Start = input.LT(1);
        int array_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal184 = null;
        IToken char_literal186 = null;
        IToken char_literal187 = null;
        csParser.variable_initializer_list_return variable_initializer_list185 = default(csParser.variable_initializer_list_return);


        object char_literal184_tree=null;
        object char_literal186_tree=null;
        object char_literal187_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 44) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:222:18: ( '{' ( variable_initializer_list )? ( ',' )? '}' )
            // G:\\downloads\\antlr\\cs.g:223:2: '{' ( variable_initializer_list )? ( ',' )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal184=(IToken)Match(input,62,FOLLOW_62_in_array_initializer1643); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal184_tree = (object)adaptor.Create(char_literal184);
            		adaptor.AddChild(root_0, char_literal184_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:223:8: ( variable_initializer_list )?
            	int alt53 = 2;
            	int LA53_0 = input.LA(1);

            	if ( ((LA53_0 >= IDENTIFIER && LA53_0 <= NULL) || LA53_0 == MINUS || LA53_0 == 62 || LA53_0 == 65 || LA53_0 == 68 || LA53_0 == 83 || LA53_0 == 85 || LA53_0 == 88 || (LA53_0 >= 93 && LA53_0 <= 98) || LA53_0 == 100 || (LA53_0 >= 102 && LA53_0 <= 106) || LA53_0 == 117 || (LA53_0 >= 132 && LA53_0 <= 133) || (LA53_0 >= 135 && LA53_0 <= 148) || (LA53_0 >= 150 && LA53_0 <= 152) || LA53_0 == 154 || (LA53_0 >= 157 && LA53_0 <= 168) || LA53_0 == 170 || (LA53_0 >= 177 && LA53_0 <= 178) || (LA53_0 >= 195 && LA53_0 <= 202)) )
            	{
            	    alt53 = 1;
            	}
            	switch (alt53) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:223:8: variable_initializer_list
            	        {
            	        	PushFollow(FOLLOW_variable_initializer_list_in_array_initializer1647);
            	        	variable_initializer_list185 = variable_initializer_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer_list185.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:223:37: ( ',' )?
            	int alt54 = 2;
            	int LA54_0 = input.LA(1);

            	if ( (LA54_0 == 89) )
            	{
            	    alt54 = 1;
            	}
            	switch (alt54) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:223:37: ','
            	        {
            	        	char_literal186=(IToken)Match(input,89,FOLLOW_89_in_array_initializer1652); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal186_tree = (object)adaptor.Create(char_literal186);
            	        		adaptor.AddChild(root_0, char_literal186_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal187=(IToken)Match(input,63,FOLLOW_63_in_array_initializer1657); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal187_tree = (object)adaptor.Create(char_literal187);
            		adaptor.AddChild(root_0, char_literal187_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 44, array_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "array_initializer"

    public class variable_initializer_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variable_initializer_list"
    // G:\\downloads\\antlr\\cs.g:224:1: variable_initializer_list : variable_initializer ( ',' variable_initializer )* ;
    public csParser.variable_initializer_list_return variable_initializer_list() // throws RecognitionException [1]
    {   
        csParser.variable_initializer_list_return retval = new csParser.variable_initializer_list_return();
        retval.Start = input.LT(1);
        int variable_initializer_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal189 = null;
        csParser.variable_initializer_return variable_initializer188 = default(csParser.variable_initializer_return);

        csParser.variable_initializer_return variable_initializer190 = default(csParser.variable_initializer_return);


        object char_literal189_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 45) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:224:26: ( variable_initializer ( ',' variable_initializer )* )
            // G:\\downloads\\antlr\\cs.g:225:2: variable_initializer ( ',' variable_initializer )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_variable_initializer_in_variable_initializer_list1665);
            	variable_initializer188 = variable_initializer();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer188.Tree);
            	// G:\\downloads\\antlr\\cs.g:225:23: ( ',' variable_initializer )*
            	do 
            	{
            	    int alt55 = 2;
            	    int LA55_0 = input.LA(1);

            	    if ( (LA55_0 == 89) )
            	    {
            	        int LA55_1 = input.LA(2);

            	        if ( ((LA55_1 >= IDENTIFIER && LA55_1 <= NULL) || LA55_1 == MINUS || LA55_1 == 62 || LA55_1 == 65 || LA55_1 == 68 || LA55_1 == 83 || LA55_1 == 85 || LA55_1 == 88 || (LA55_1 >= 93 && LA55_1 <= 98) || LA55_1 == 100 || (LA55_1 >= 102 && LA55_1 <= 106) || LA55_1 == 117 || (LA55_1 >= 132 && LA55_1 <= 133) || (LA55_1 >= 135 && LA55_1 <= 148) || (LA55_1 >= 150 && LA55_1 <= 152) || LA55_1 == 154 || (LA55_1 >= 157 && LA55_1 <= 168) || LA55_1 == 170 || (LA55_1 >= 177 && LA55_1 <= 178) || (LA55_1 >= 195 && LA55_1 <= 202)) )
            	        {
            	            alt55 = 1;
            	        }


            	    }


            	    switch (alt55) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:225:24: ',' variable_initializer
            			    {
            			    	char_literal189=(IToken)Match(input,89,FOLLOW_89_in_variable_initializer_list1668); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal189_tree = (object)adaptor.Create(char_literal189);
            			    		adaptor.AddChild(root_0, char_literal189_tree);
            			    	}
            			    	PushFollow(FOLLOW_variable_initializer_in_variable_initializer_list1670);
            			    	variable_initializer190 = variable_initializer();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer190.Tree);

            			    }
            			    break;

            			default:
            			    goto loop55;
            	    }
            	} while (true);

            	loop55:
            		;	// Stops C# compiler whining that label 'loop55' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 45, variable_initializer_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variable_initializer_list"

    public class variable_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variable_initializer"
    // G:\\downloads\\antlr\\cs.g:226:1: variable_initializer : ( expression | array_initializer );
    public csParser.variable_initializer_return variable_initializer() // throws RecognitionException [1]
    {   
        csParser.variable_initializer_return retval = new csParser.variable_initializer_return();
        retval.Start = input.LT(1);
        int variable_initializer_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression191 = default(csParser.expression_return);

        csParser.array_initializer_return array_initializer192 = default(csParser.array_initializer_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 46) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:226:21: ( expression | array_initializer )
            int alt56 = 2;
            int LA56_0 = input.LA(1);

            if ( ((LA56_0 >= IDENTIFIER && LA56_0 <= NULL) || LA56_0 == MINUS || LA56_0 == 65 || LA56_0 == 68 || LA56_0 == 83 || LA56_0 == 85 || LA56_0 == 88 || (LA56_0 >= 93 && LA56_0 <= 98) || LA56_0 == 100 || (LA56_0 >= 102 && LA56_0 <= 106) || LA56_0 == 117 || (LA56_0 >= 132 && LA56_0 <= 133) || (LA56_0 >= 135 && LA56_0 <= 148) || (LA56_0 >= 150 && LA56_0 <= 152) || LA56_0 == 154 || (LA56_0 >= 157 && LA56_0 <= 168) || LA56_0 == 170 || (LA56_0 >= 177 && LA56_0 <= 178) || (LA56_0 >= 195 && LA56_0 <= 202)) )
            {
                alt56 = 1;
            }
            else if ( (LA56_0 == 62) )
            {
                alt56 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d56s0 =
                    new NoViableAltException("", 56, 0, input);

                throw nvae_d56s0;
            }
            switch (alt56) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:227:2: expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_in_variable_initializer1680);
                    	expression191 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression191.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:227:15: array_initializer
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_array_initializer_in_variable_initializer1684);
                    	array_initializer192 = array_initializer();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer192.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 46, variable_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variable_initializer"

    public class sizeof_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "sizeof_expression"
    // G:\\downloads\\antlr\\cs.g:228:1: sizeof_expression : 'sizeof' '(' unmanaged_type ')' ;
    public csParser.sizeof_expression_return sizeof_expression() // throws RecognitionException [1]
    {   
        csParser.sizeof_expression_return retval = new csParser.sizeof_expression_return();
        retval.Start = input.LT(1);
        int sizeof_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal193 = null;
        IToken char_literal194 = null;
        IToken char_literal196 = null;
        csParser.unmanaged_type_return unmanaged_type195 = default(csParser.unmanaged_type_return);


        object string_literal193_tree=null;
        object char_literal194_tree=null;
        object char_literal196_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 47) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:228:18: ( 'sizeof' '(' unmanaged_type ')' )
            // G:\\downloads\\antlr\\cs.g:229:2: 'sizeof' '(' unmanaged_type ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal193=(IToken)Match(input,93,FOLLOW_93_in_sizeof_expression1692); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal193_tree = (object)adaptor.Create(string_literal193);
            		adaptor.AddChild(root_0, string_literal193_tree);
            	}
            	char_literal194=(IToken)Match(input,88,FOLLOW_88_in_sizeof_expression1696); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal194_tree = (object)adaptor.Create(char_literal194);
            		adaptor.AddChild(root_0, char_literal194_tree);
            	}
            	PushFollow(FOLLOW_unmanaged_type_in_sizeof_expression1700);
            	unmanaged_type195 = unmanaged_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unmanaged_type195.Tree);
            	char_literal196=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_sizeof_expression1704); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal196_tree = (object)adaptor.Create(char_literal196);
            		adaptor.AddChild(root_0, char_literal196_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 47, sizeof_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "sizeof_expression"

    public class checked_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "checked_expression"
    // G:\\downloads\\antlr\\cs.g:230:1: checked_expression : 'checked' '(' expression ')' ;
    public csParser.checked_expression_return checked_expression() // throws RecognitionException [1]
    {   
        csParser.checked_expression_return retval = new csParser.checked_expression_return();
        retval.Start = input.LT(1);
        int checked_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal197 = null;
        IToken char_literal198 = null;
        IToken char_literal200 = null;
        csParser.expression_return expression199 = default(csParser.expression_return);


        object string_literal197_tree=null;
        object char_literal198_tree=null;
        object char_literal200_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 48) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:230:19: ( 'checked' '(' expression ')' )
            // G:\\downloads\\antlr\\cs.g:231:2: 'checked' '(' expression ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal197=(IToken)Match(input,94,FOLLOW_94_in_checked_expression1712); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal197_tree = (object)adaptor.Create(string_literal197);
            		adaptor.AddChild(root_0, string_literal197_tree);
            	}
            	char_literal198=(IToken)Match(input,88,FOLLOW_88_in_checked_expression1716); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal198_tree = (object)adaptor.Create(char_literal198);
            		adaptor.AddChild(root_0, char_literal198_tree);
            	}
            	PushFollow(FOLLOW_expression_in_checked_expression1720);
            	expression199 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression199.Tree);
            	char_literal200=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_checked_expression1724); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal200_tree = (object)adaptor.Create(char_literal200);
            		adaptor.AddChild(root_0, char_literal200_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 48, checked_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "checked_expression"

    public class unchecked_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unchecked_expression"
    // G:\\downloads\\antlr\\cs.g:232:1: unchecked_expression : 'unchecked' '(' expression ')' ;
    public csParser.unchecked_expression_return unchecked_expression() // throws RecognitionException [1]
    {   
        csParser.unchecked_expression_return retval = new csParser.unchecked_expression_return();
        retval.Start = input.LT(1);
        int unchecked_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal201 = null;
        IToken char_literal202 = null;
        IToken char_literal204 = null;
        csParser.expression_return expression203 = default(csParser.expression_return);


        object string_literal201_tree=null;
        object char_literal202_tree=null;
        object char_literal204_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 49) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:232:21: ( 'unchecked' '(' expression ')' )
            // G:\\downloads\\antlr\\cs.g:233:2: 'unchecked' '(' expression ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal201=(IToken)Match(input,95,FOLLOW_95_in_unchecked_expression1733); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal201_tree = (object)adaptor.Create(string_literal201);
            		adaptor.AddChild(root_0, string_literal201_tree);
            	}
            	char_literal202=(IToken)Match(input,88,FOLLOW_88_in_unchecked_expression1737); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal202_tree = (object)adaptor.Create(char_literal202);
            		adaptor.AddChild(root_0, char_literal202_tree);
            	}
            	PushFollow(FOLLOW_expression_in_unchecked_expression1741);
            	expression203 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression203.Tree);
            	char_literal204=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_unchecked_expression1745); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal204_tree = (object)adaptor.Create(char_literal204);
            		adaptor.AddChild(root_0, char_literal204_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 49, unchecked_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unchecked_expression"

    public class default_value_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "default_value_expression"
    // G:\\downloads\\antlr\\cs.g:234:1: default_value_expression : 'default' '(' type ')' ;
    public csParser.default_value_expression_return default_value_expression() // throws RecognitionException [1]
    {   
        csParser.default_value_expression_return retval = new csParser.default_value_expression_return();
        retval.Start = input.LT(1);
        int default_value_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal205 = null;
        IToken char_literal206 = null;
        IToken char_literal208 = null;
        csParser.type_return type207 = default(csParser.type_return);


        object string_literal205_tree=null;
        object char_literal206_tree=null;
        object char_literal208_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 50) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:234:25: ( 'default' '(' type ')' )
            // G:\\downloads\\antlr\\cs.g:235:2: 'default' '(' type ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal205=(IToken)Match(input,96,FOLLOW_96_in_default_value_expression1754); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal205_tree = (object)adaptor.Create(string_literal205);
            		adaptor.AddChild(root_0, string_literal205_tree);
            	}
            	char_literal206=(IToken)Match(input,88,FOLLOW_88_in_default_value_expression1758); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal206_tree = (object)adaptor.Create(char_literal206);
            		adaptor.AddChild(root_0, char_literal206_tree);
            	}
            	PushFollow(FOLLOW_type_in_default_value_expression1762);
            	type207 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type207.Tree);
            	char_literal208=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_default_value_expression1766); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal208_tree = (object)adaptor.Create(char_literal208);
            		adaptor.AddChild(root_0, char_literal208_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 50, default_value_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "default_value_expression"

    public class anonymous_method_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "anonymous_method_expression"
    // G:\\downloads\\antlr\\cs.g:236:1: anonymous_method_expression : 'delegate' ( explicit_anonymous_function_signature )? block ;
    public csParser.anonymous_method_expression_return anonymous_method_expression() // throws RecognitionException [1]
    {   
        csParser.anonymous_method_expression_return retval = new csParser.anonymous_method_expression_return();
        retval.Start = input.LT(1);
        int anonymous_method_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal209 = null;
        csParser.explicit_anonymous_function_signature_return explicit_anonymous_function_signature210 = default(csParser.explicit_anonymous_function_signature_return);

        csParser.block_return block211 = default(csParser.block_return);


        object string_literal209_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 51) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:236:28: ( 'delegate' ( explicit_anonymous_function_signature )? block )
            // G:\\downloads\\antlr\\cs.g:237:2: 'delegate' ( explicit_anonymous_function_signature )? block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal209=(IToken)Match(input,97,FOLLOW_97_in_anonymous_method_expression1774); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal209_tree = (object)adaptor.Create(string_literal209);
            		adaptor.AddChild(root_0, string_literal209_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:237:15: ( explicit_anonymous_function_signature )?
            	int alt57 = 2;
            	int LA57_0 = input.LA(1);

            	if ( (LA57_0 == 88) )
            	{
            	    alt57 = 1;
            	}
            	switch (alt57) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:237:15: explicit_anonymous_function_signature
            	        {
            	        	PushFollow(FOLLOW_explicit_anonymous_function_signature_in_anonymous_method_expression1778);
            	        	explicit_anonymous_function_signature210 = explicit_anonymous_function_signature();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_signature210.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_block_in_anonymous_method_expression1783);
            	block211 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block211.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 51, anonymous_method_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "anonymous_method_expression"

    public class explicit_anonymous_function_signature_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "explicit_anonymous_function_signature"
    // G:\\downloads\\antlr\\cs.g:238:1: explicit_anonymous_function_signature : '(' ( explicit_anonymous_function_parameter_list )? ')' ;
    public csParser.explicit_anonymous_function_signature_return explicit_anonymous_function_signature() // throws RecognitionException [1]
    {   
        csParser.explicit_anonymous_function_signature_return retval = new csParser.explicit_anonymous_function_signature_return();
        retval.Start = input.LT(1);
        int explicit_anonymous_function_signature_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal212 = null;
        IToken char_literal214 = null;
        csParser.explicit_anonymous_function_parameter_list_return explicit_anonymous_function_parameter_list213 = default(csParser.explicit_anonymous_function_parameter_list_return);


        object char_literal212_tree=null;
        object char_literal214_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 52) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:238:38: ( '(' ( explicit_anonymous_function_parameter_list )? ')' )
            // G:\\downloads\\antlr\\cs.g:239:2: '(' ( explicit_anonymous_function_parameter_list )? ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal212=(IToken)Match(input,88,FOLLOW_88_in_explicit_anonymous_function_signature1790); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal212_tree = (object)adaptor.Create(char_literal212);
            		adaptor.AddChild(root_0, char_literal212_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:239:8: ( explicit_anonymous_function_parameter_list )?
            	int alt58 = 2;
            	int LA58_0 = input.LA(1);

            	if ( (LA58_0 == IDENTIFIER || LA58_0 == 65 || LA58_0 == 82 || (LA58_0 >= 91 && LA58_0 <= 92) || (LA58_0 >= 132 && LA58_0 <= 133) || (LA58_0 >= 135 && LA58_0 <= 148) || (LA58_0 >= 150 && LA58_0 <= 152) || LA58_0 == 154 || (LA58_0 >= 157 && LA58_0 <= 168) || LA58_0 == 170 || (LA58_0 >= 177 && LA58_0 <= 178) || (LA58_0 >= 195 && LA58_0 <= 202)) )
            	{
            	    alt58 = 1;
            	}
            	switch (alt58) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:239:8: explicit_anonymous_function_parameter_list
            	        {
            	        	PushFollow(FOLLOW_explicit_anonymous_function_parameter_list_in_explicit_anonymous_function_signature1794);
            	        	explicit_anonymous_function_parameter_list213 = explicit_anonymous_function_parameter_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter_list213.Tree);

            	        }
            	        break;

            	}

            	char_literal214=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_explicit_anonymous_function_signature1799); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal214_tree = (object)adaptor.Create(char_literal214);
            		adaptor.AddChild(root_0, char_literal214_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 52, explicit_anonymous_function_signature_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "explicit_anonymous_function_signature"

    public class explicit_anonymous_function_parameter_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "explicit_anonymous_function_parameter_list"
    // G:\\downloads\\antlr\\cs.g:240:1: explicit_anonymous_function_parameter_list : explicit_anonymous_function_parameter ( ',' explicit_anonymous_function_parameter )* ;
    public csParser.explicit_anonymous_function_parameter_list_return explicit_anonymous_function_parameter_list() // throws RecognitionException [1]
    {   
        csParser.explicit_anonymous_function_parameter_list_return retval = new csParser.explicit_anonymous_function_parameter_list_return();
        retval.Start = input.LT(1);
        int explicit_anonymous_function_parameter_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal216 = null;
        csParser.explicit_anonymous_function_parameter_return explicit_anonymous_function_parameter215 = default(csParser.explicit_anonymous_function_parameter_return);

        csParser.explicit_anonymous_function_parameter_return explicit_anonymous_function_parameter217 = default(csParser.explicit_anonymous_function_parameter_return);


        object char_literal216_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 53) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:240:43: ( explicit_anonymous_function_parameter ( ',' explicit_anonymous_function_parameter )* )
            // G:\\downloads\\antlr\\cs.g:241:2: explicit_anonymous_function_parameter ( ',' explicit_anonymous_function_parameter )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1807);
            	explicit_anonymous_function_parameter215 = explicit_anonymous_function_parameter();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter215.Tree);
            	// G:\\downloads\\antlr\\cs.g:241:42: ( ',' explicit_anonymous_function_parameter )*
            	do 
            	{
            	    int alt59 = 2;
            	    int LA59_0 = input.LA(1);

            	    if ( (LA59_0 == 89) )
            	    {
            	        alt59 = 1;
            	    }


            	    switch (alt59) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:241:43: ',' explicit_anonymous_function_parameter
            			    {
            			    	char_literal216=(IToken)Match(input,89,FOLLOW_89_in_explicit_anonymous_function_parameter_list1812); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal216_tree = (object)adaptor.Create(char_literal216);
            			    		adaptor.AddChild(root_0, char_literal216_tree);
            			    	}
            			    	PushFollow(FOLLOW_explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1816);
            			    	explicit_anonymous_function_parameter217 = explicit_anonymous_function_parameter();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter217.Tree);

            			    }
            			    break;

            			default:
            			    goto loop59;
            	    }
            	} while (true);

            	loop59:
            		;	// Stops C# compiler whining that label 'loop59' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 53, explicit_anonymous_function_parameter_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "explicit_anonymous_function_parameter_list"

    public class explicit_anonymous_function_parameter_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "explicit_anonymous_function_parameter"
    // G:\\downloads\\antlr\\cs.g:242:1: explicit_anonymous_function_parameter : ( anonymous_function_parameter_modifier )? type identifier ;
    public csParser.explicit_anonymous_function_parameter_return explicit_anonymous_function_parameter() // throws RecognitionException [1]
    {   
        csParser.explicit_anonymous_function_parameter_return retval = new csParser.explicit_anonymous_function_parameter_return();
        retval.Start = input.LT(1);
        int explicit_anonymous_function_parameter_StartIndex = input.Index();
        object root_0 = null;

        csParser.anonymous_function_parameter_modifier_return anonymous_function_parameter_modifier218 = default(csParser.anonymous_function_parameter_modifier_return);

        csParser.type_return type219 = default(csParser.type_return);

        csParser.identifier_return identifier220 = default(csParser.identifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 54) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:242:38: ( ( anonymous_function_parameter_modifier )? type identifier )
            // G:\\downloads\\antlr\\cs.g:243:2: ( anonymous_function_parameter_modifier )? type identifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:243:2: ( anonymous_function_parameter_modifier )?
            	int alt60 = 2;
            	int LA60_0 = input.LA(1);

            	if ( ((LA60_0 >= 91 && LA60_0 <= 92)) )
            	{
            	    alt60 = 1;
            	}
            	switch (alt60) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:243:2: anonymous_function_parameter_modifier
            	        {
            	        	PushFollow(FOLLOW_anonymous_function_parameter_modifier_in_explicit_anonymous_function_parameter1827);
            	        	anonymous_function_parameter_modifier218 = anonymous_function_parameter_modifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_function_parameter_modifier218.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_type_in_explicit_anonymous_function_parameter1832);
            	type219 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type219.Tree);
            	PushFollow(FOLLOW_identifier_in_explicit_anonymous_function_parameter1836);
            	identifier220 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier220.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 54, explicit_anonymous_function_parameter_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "explicit_anonymous_function_parameter"

    public class anonymous_function_parameter_modifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "anonymous_function_parameter_modifier"
    // G:\\downloads\\antlr\\cs.g:244:1: anonymous_function_parameter_modifier : ( 'ref' | 'out' );
    public csParser.anonymous_function_parameter_modifier_return anonymous_function_parameter_modifier() // throws RecognitionException [1]
    {   
        csParser.anonymous_function_parameter_modifier_return retval = new csParser.anonymous_function_parameter_modifier_return();
        retval.Start = input.LT(1);
        int anonymous_function_parameter_modifier_StartIndex = input.Index();
        object root_0 = null;

        IToken set221 = null;

        object set221_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 55) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:244:38: ( 'ref' | 'out' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set221 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 91 && input.LA(1) <= 92) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set221));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 55, anonymous_function_parameter_modifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "anonymous_function_parameter_modifier"

    public class object_creation_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "object_creation_expression"
    // G:\\downloads\\antlr\\cs.g:249:1: object_creation_expression : type ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer ) ;
    public csParser.object_creation_expression_return object_creation_expression() // throws RecognitionException [1]
    {   
        csParser.object_creation_expression_return retval = new csParser.object_creation_expression_return();
        retval.Start = input.LT(1);
        int object_creation_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal223 = null;
        IToken char_literal225 = null;
        csParser.type_return type222 = default(csParser.type_return);

        csParser.argument_list_return argument_list224 = default(csParser.argument_list_return);

        csParser.object_or_collection_initializer_return object_or_collection_initializer226 = default(csParser.object_or_collection_initializer_return);

        csParser.object_or_collection_initializer_return object_or_collection_initializer227 = default(csParser.object_or_collection_initializer_return);


        object char_literal223_tree=null;
        object char_literal225_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 56) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:249:27: ( type ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer ) )
            // G:\\downloads\\antlr\\cs.g:251:2: type ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_object_creation_expression1860);
            	type222 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type222.Tree);
            	// G:\\downloads\\antlr\\cs.g:252:3: ( '(' ( argument_list )? ')' ( object_or_collection_initializer )? | object_or_collection_initializer )
            	int alt63 = 2;
            	int LA63_0 = input.LA(1);

            	if ( (LA63_0 == 88) )
            	{
            	    alt63 = 1;
            	}
            	else if ( (LA63_0 == 62) )
            	{
            	    alt63 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d63s0 =
            	        new NoViableAltException("", 63, 0, input);

            	    throw nvae_d63s0;
            	}
            	switch (alt63) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:252:5: '(' ( argument_list )? ')' ( object_or_collection_initializer )?
            	        {
            	        	char_literal223=(IToken)Match(input,88,FOLLOW_88_in_object_creation_expression1869); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal223_tree = (object)adaptor.Create(char_literal223);
            	        		adaptor.AddChild(root_0, char_literal223_tree);
            	        	}
            	        	// G:\\downloads\\antlr\\cs.g:252:11: ( argument_list )?
            	        	int alt61 = 2;
            	        	int LA61_0 = input.LA(1);

            	        	if ( ((LA61_0 >= IDENTIFIER && LA61_0 <= NULL) || LA61_0 == MINUS || LA61_0 == 65 || LA61_0 == 68 || LA61_0 == 83 || LA61_0 == 85 || LA61_0 == 88 || (LA61_0 >= 91 && LA61_0 <= 98) || LA61_0 == 100 || (LA61_0 >= 102 && LA61_0 <= 106) || LA61_0 == 117 || (LA61_0 >= 132 && LA61_0 <= 133) || (LA61_0 >= 135 && LA61_0 <= 148) || (LA61_0 >= 150 && LA61_0 <= 152) || LA61_0 == 154 || (LA61_0 >= 157 && LA61_0 <= 168) || LA61_0 == 170 || (LA61_0 >= 177 && LA61_0 <= 178) || (LA61_0 >= 195 && LA61_0 <= 202)) )
            	        	{
            	        	    alt61 = 1;
            	        	}
            	        	switch (alt61) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:252:11: argument_list
            	        	        {
            	        	        	PushFollow(FOLLOW_argument_list_in_object_creation_expression1873);
            	        	        	argument_list224 = argument_list();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_list224.Tree);

            	        	        }
            	        	        break;

            	        	}

            	        	char_literal225=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_object_creation_expression1878); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal225_tree = (object)adaptor.Create(char_literal225);
            	        		adaptor.AddChild(root_0, char_literal225_tree);
            	        	}
            	        	// G:\\downloads\\antlr\\cs.g:252:34: ( object_or_collection_initializer )?
            	        	int alt62 = 2;
            	        	int LA62_0 = input.LA(1);

            	        	if ( (LA62_0 == 62) )
            	        	{
            	        	    alt62 = 1;
            	        	}
            	        	switch (alt62) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:252:34: object_or_collection_initializer
            	        	        {
            	        	        	PushFollow(FOLLOW_object_or_collection_initializer_in_object_creation_expression1882);
            	        	        	object_or_collection_initializer226 = object_or_collection_initializer();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_or_collection_initializer226.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:253:7: object_or_collection_initializer
            	        {
            	        	PushFollow(FOLLOW_object_or_collection_initializer_in_object_creation_expression1893);
            	        	object_or_collection_initializer227 = object_or_collection_initializer();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_or_collection_initializer227.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 56, object_creation_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "object_creation_expression"

    public class object_or_collection_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "object_or_collection_initializer"
    // G:\\downloads\\antlr\\cs.g:255:1: object_or_collection_initializer : '{' ( object_initializer | collection_initializer ) ;
    public csParser.object_or_collection_initializer_return object_or_collection_initializer() // throws RecognitionException [1]
    {   
        csParser.object_or_collection_initializer_return retval = new csParser.object_or_collection_initializer_return();
        retval.Start = input.LT(1);
        int object_or_collection_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal228 = null;
        csParser.object_initializer_return object_initializer229 = default(csParser.object_initializer_return);

        csParser.collection_initializer_return collection_initializer230 = default(csParser.collection_initializer_return);


        object char_literal228_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 57) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:255:33: ( '{' ( object_initializer | collection_initializer ) )
            // G:\\downloads\\antlr\\cs.g:256:2: '{' ( object_initializer | collection_initializer )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal228=(IToken)Match(input,62,FOLLOW_62_in_object_or_collection_initializer1905); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal228_tree = (object)adaptor.Create(char_literal228);
            		adaptor.AddChild(root_0, char_literal228_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:256:7: ( object_initializer | collection_initializer )
            	int alt64 = 2;
            	switch ( input.LA(1) ) 
            	{
            	case 133:
            		{
            	    int LA64_1 = input.LA(2);

            	    if ( (LA64_1 == 66) )
            	    {
            	        alt64 = 1;
            	    }
            	    else if ( (LA64_1 == IDENTIFIER || (LA64_1 >= DOT && LA64_1 <= GT) || LA64_1 == 63 || LA64_1 == 65 || LA64_1 == 82 || LA64_1 == 84 || LA64_1 == 86 || (LA64_1 >= 88 && LA64_1 <= 89) || (LA64_1 >= 99 && LA64_1 <= 104) || (LA64_1 >= 116 && LA64_1 <= 133) || (LA64_1 >= 135 && LA64_1 <= 148) || (LA64_1 >= 150 && LA64_1 <= 152) || LA64_1 == 154 || (LA64_1 >= 157 && LA64_1 <= 168) || LA64_1 == 170 || (LA64_1 >= 177 && LA64_1 <= 178) || (LA64_1 >= 195 && LA64_1 <= 202)) )
            	    {
            	        alt64 = 2;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        NoViableAltException nvae_d64s1 =
            	            new NoViableAltException("", 64, 1, input);

            	        throw nvae_d64s1;
            	    }
            	    }
            	    break;
            	case 63:
            	case 89:
            		{
            	    alt64 = 1;
            	    }
            	    break;
            	case Real_literal:
            	case NUMBER:
            	case Hex_number:
            	case Character_literal:
            	case STRINGLITERAL:
            	case Verbatim_string_literal:
            	case TRUE:
            	case FALSE:
            	case NULL:
            	case MINUS:
            	case 62:
            	case 68:
            	case 83:
            	case 85:
            	case 88:
            	case 93:
            	case 94:
            	case 95:
            	case 96:
            	case 97:
            	case 98:
            	case 100:
            	case 102:
            	case 103:
            	case 104:
            	case 105:
            	case 106:
            	case 117:
            	case 160:
            	case 161:
            	case 162:
            	case 163:
            	case 164:
            	case 165:
            	case 166:
            	case 167:
            	case 168:
            	case 196:
            	case 197:
            	case 198:
            	case 199:
            	case 200:
            	case 201:
            		{
            	    alt64 = 2;
            	    }
            	    break;
            	case IDENTIFIER:
            	case 65:
            	case 132:
            	case 135:
            	case 136:
            	case 137:
            	case 138:
            	case 139:
            	case 140:
            	case 141:
            	case 142:
            	case 143:
            	case 144:
            	case 145:
            	case 146:
            	case 147:
            	case 148:
            	case 150:
            	case 151:
            	case 152:
            	case 154:
            	case 157:
            	case 158:
            	case 159:
            	case 170:
            	case 177:
            	case 178:
            	case 195:
            	case 202:
            		{
            	    int LA64_4 = input.LA(2);

            	    if ( (LA64_4 == 66) )
            	    {
            	        alt64 = 1;
            	    }
            	    else if ( ((LA64_4 >= DOT && LA64_4 <= GT) || LA64_4 == 63 || LA64_4 == 84 || LA64_4 == 86 || (LA64_4 >= 88 && LA64_4 <= 89) || (LA64_4 >= 99 && LA64_4 <= 104) || (LA64_4 >= 116 && LA64_4 <= 131)) )
            	    {
            	        alt64 = 2;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        NoViableAltException nvae_d64s4 =
            	            new NoViableAltException("", 64, 4, input);

            	        throw nvae_d64s4;
            	    }
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		    NoViableAltException nvae_d64s0 =
            		        new NoViableAltException("", 64, 0, input);

            		    throw nvae_d64s0;
            	}

            	switch (alt64) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:256:8: object_initializer
            	        {
            	        	PushFollow(FOLLOW_object_initializer_in_object_or_collection_initializer1909);
            	        	object_initializer229 = object_initializer();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_initializer229.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:257:5: collection_initializer
            	        {
            	        	PushFollow(FOLLOW_collection_initializer_in_object_or_collection_initializer1916);
            	        	collection_initializer230 = collection_initializer();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, collection_initializer230.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 57, object_or_collection_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "object_or_collection_initializer"

    public class collection_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "collection_initializer"
    // G:\\downloads\\antlr\\cs.g:258:1: collection_initializer : element_initializer_list ( ',' )? '}' ;
    public csParser.collection_initializer_return collection_initializer() // throws RecognitionException [1]
    {   
        csParser.collection_initializer_return retval = new csParser.collection_initializer_return();
        retval.Start = input.LT(1);
        int collection_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal232 = null;
        IToken char_literal233 = null;
        csParser.element_initializer_list_return element_initializer_list231 = default(csParser.element_initializer_list_return);


        object char_literal232_tree=null;
        object char_literal233_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 58) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:258:23: ( element_initializer_list ( ',' )? '}' )
            // G:\\downloads\\antlr\\cs.g:259:2: element_initializer_list ( ',' )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_element_initializer_list_in_collection_initializer1926);
            	element_initializer_list231 = element_initializer_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, element_initializer_list231.Tree);
            	// G:\\downloads\\antlr\\cs.g:259:29: ( ',' )?
            	int alt65 = 2;
            	int LA65_0 = input.LA(1);

            	if ( (LA65_0 == 89) )
            	{
            	    alt65 = 1;
            	}
            	switch (alt65) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:259:29: ','
            	        {
            	        	char_literal232=(IToken)Match(input,89,FOLLOW_89_in_collection_initializer1930); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal232_tree = (object)adaptor.Create(char_literal232);
            	        		adaptor.AddChild(root_0, char_literal232_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal233=(IToken)Match(input,63,FOLLOW_63_in_collection_initializer1935); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal233_tree = (object)adaptor.Create(char_literal233);
            		adaptor.AddChild(root_0, char_literal233_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 58, collection_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "collection_initializer"

    public class element_initializer_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "element_initializer_list"
    // G:\\downloads\\antlr\\cs.g:260:1: element_initializer_list : element_initializer ( ',' element_initializer )* ;
    public csParser.element_initializer_list_return element_initializer_list() // throws RecognitionException [1]
    {   
        csParser.element_initializer_list_return retval = new csParser.element_initializer_list_return();
        retval.Start = input.LT(1);
        int element_initializer_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal235 = null;
        csParser.element_initializer_return element_initializer234 = default(csParser.element_initializer_return);

        csParser.element_initializer_return element_initializer236 = default(csParser.element_initializer_return);


        object char_literal235_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 59) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:260:25: ( element_initializer ( ',' element_initializer )* )
            // G:\\downloads\\antlr\\cs.g:261:2: element_initializer ( ',' element_initializer )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_element_initializer_in_element_initializer_list1944);
            	element_initializer234 = element_initializer();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, element_initializer234.Tree);
            	// G:\\downloads\\antlr\\cs.g:261:23: ( ',' element_initializer )*
            	do 
            	{
            	    int alt66 = 2;
            	    int LA66_0 = input.LA(1);

            	    if ( (LA66_0 == 89) )
            	    {
            	        int LA66_1 = input.LA(2);

            	        if ( ((LA66_1 >= IDENTIFIER && LA66_1 <= NULL) || LA66_1 == MINUS || LA66_1 == 62 || LA66_1 == 65 || LA66_1 == 68 || LA66_1 == 83 || LA66_1 == 85 || LA66_1 == 88 || (LA66_1 >= 93 && LA66_1 <= 98) || LA66_1 == 100 || (LA66_1 >= 102 && LA66_1 <= 106) || LA66_1 == 117 || (LA66_1 >= 132 && LA66_1 <= 133) || (LA66_1 >= 135 && LA66_1 <= 148) || (LA66_1 >= 150 && LA66_1 <= 152) || LA66_1 == 154 || (LA66_1 >= 157 && LA66_1 <= 168) || LA66_1 == 170 || (LA66_1 >= 177 && LA66_1 <= 178) || (LA66_1 >= 195 && LA66_1 <= 202)) )
            	        {
            	            alt66 = 1;
            	        }


            	    }


            	    switch (alt66) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:261:24: ',' element_initializer
            			    {
            			    	char_literal235=(IToken)Match(input,89,FOLLOW_89_in_element_initializer_list1948); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal235_tree = (object)adaptor.Create(char_literal235);
            			    		adaptor.AddChild(root_0, char_literal235_tree);
            			    	}
            			    	PushFollow(FOLLOW_element_initializer_in_element_initializer_list1950);
            			    	element_initializer236 = element_initializer();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, element_initializer236.Tree);

            			    }
            			    break;

            			default:
            			    goto loop66;
            	    }
            	} while (true);

            	loop66:
            		;	// Stops C# compiler whining that label 'loop66' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 59, element_initializer_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "element_initializer_list"

    public class element_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "element_initializer"
    // G:\\downloads\\antlr\\cs.g:262:1: element_initializer : ( non_assignment_expression | '{' expression_list '}' );
    public csParser.element_initializer_return element_initializer() // throws RecognitionException [1]
    {   
        csParser.element_initializer_return retval = new csParser.element_initializer_return();
        retval.Start = input.LT(1);
        int element_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal238 = null;
        IToken char_literal240 = null;
        csParser.non_assignment_expression_return non_assignment_expression237 = default(csParser.non_assignment_expression_return);

        csParser.expression_list_return expression_list239 = default(csParser.expression_list_return);


        object char_literal238_tree=null;
        object char_literal240_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 60) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:262:20: ( non_assignment_expression | '{' expression_list '}' )
            int alt67 = 2;
            int LA67_0 = input.LA(1);

            if ( ((LA67_0 >= IDENTIFIER && LA67_0 <= NULL) || LA67_0 == MINUS || LA67_0 == 65 || LA67_0 == 68 || LA67_0 == 83 || LA67_0 == 85 || LA67_0 == 88 || (LA67_0 >= 93 && LA67_0 <= 98) || LA67_0 == 100 || (LA67_0 >= 102 && LA67_0 <= 106) || LA67_0 == 117 || (LA67_0 >= 132 && LA67_0 <= 133) || (LA67_0 >= 135 && LA67_0 <= 148) || (LA67_0 >= 150 && LA67_0 <= 152) || LA67_0 == 154 || (LA67_0 >= 157 && LA67_0 <= 168) || LA67_0 == 170 || (LA67_0 >= 177 && LA67_0 <= 178) || (LA67_0 >= 195 && LA67_0 <= 202)) )
            {
                alt67 = 1;
            }
            else if ( (LA67_0 == 62) )
            {
                alt67 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d67s0 =
                    new NoViableAltException("", 67, 0, input);

                throw nvae_d67s0;
            }
            switch (alt67) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:263:2: non_assignment_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_non_assignment_expression_in_element_initializer1961);
                    	non_assignment_expression237 = non_assignment_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_assignment_expression237.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:264:4: '{' expression_list '}'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal238=(IToken)Match(input,62,FOLLOW_62_in_element_initializer1967); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal238_tree = (object)adaptor.Create(char_literal238);
                    		adaptor.AddChild(root_0, char_literal238_tree);
                    	}
                    	PushFollow(FOLLOW_expression_list_in_element_initializer1971);
                    	expression_list239 = expression_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_list239.Tree);
                    	char_literal240=(IToken)Match(input,63,FOLLOW_63_in_element_initializer1975); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal240_tree = (object)adaptor.Create(char_literal240);
                    		adaptor.AddChild(root_0, char_literal240_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 60, element_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "element_initializer"

    public class object_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "object_initializer"
    // G:\\downloads\\antlr\\cs.g:271:1: object_initializer : ( member_initializer_list )? ( ',' )? '}' ;
    public csParser.object_initializer_return object_initializer() // throws RecognitionException [1]
    {   
        csParser.object_initializer_return retval = new csParser.object_initializer_return();
        retval.Start = input.LT(1);
        int object_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal242 = null;
        IToken char_literal243 = null;
        csParser.member_initializer_list_return member_initializer_list241 = default(csParser.member_initializer_list_return);


        object char_literal242_tree=null;
        object char_literal243_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 61) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:271:19: ( ( member_initializer_list )? ( ',' )? '}' )
            // G:\\downloads\\antlr\\cs.g:272:2: ( member_initializer_list )? ( ',' )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:272:2: ( member_initializer_list )?
            	int alt68 = 2;
            	int LA68_0 = input.LA(1);

            	if ( (LA68_0 == IDENTIFIER || LA68_0 == 65 || (LA68_0 >= 132 && LA68_0 <= 133) || (LA68_0 >= 135 && LA68_0 <= 148) || (LA68_0 >= 150 && LA68_0 <= 152) || LA68_0 == 154 || (LA68_0 >= 157 && LA68_0 <= 159) || LA68_0 == 170 || (LA68_0 >= 177 && LA68_0 <= 178) || LA68_0 == 195 || LA68_0 == 202) )
            	{
            	    alt68 = 1;
            	}
            	switch (alt68) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:272:2: member_initializer_list
            	        {
            	        	PushFollow(FOLLOW_member_initializer_list_in_object_initializer1990);
            	        	member_initializer_list241 = member_initializer_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_initializer_list241.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:272:29: ( ',' )?
            	int alt69 = 2;
            	int LA69_0 = input.LA(1);

            	if ( (LA69_0 == 89) )
            	{
            	    alt69 = 1;
            	}
            	switch (alt69) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:272:29: ','
            	        {
            	        	char_literal242=(IToken)Match(input,89,FOLLOW_89_in_object_initializer1995); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal242_tree = (object)adaptor.Create(char_literal242);
            	        		adaptor.AddChild(root_0, char_literal242_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal243=(IToken)Match(input,63,FOLLOW_63_in_object_initializer2000); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal243_tree = (object)adaptor.Create(char_literal243);
            		adaptor.AddChild(root_0, char_literal243_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 61, object_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "object_initializer"

    public class member_initializer_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "member_initializer_list"
    // G:\\downloads\\antlr\\cs.g:273:1: member_initializer_list : member_initializer ( ',' member_initializer ) ;
    public csParser.member_initializer_list_return member_initializer_list() // throws RecognitionException [1]
    {   
        csParser.member_initializer_list_return retval = new csParser.member_initializer_list_return();
        retval.Start = input.LT(1);
        int member_initializer_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal245 = null;
        csParser.member_initializer_return member_initializer244 = default(csParser.member_initializer_return);

        csParser.member_initializer_return member_initializer246 = default(csParser.member_initializer_return);


        object char_literal245_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 62) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:273:24: ( member_initializer ( ',' member_initializer ) )
            // G:\\downloads\\antlr\\cs.g:274:2: member_initializer ( ',' member_initializer )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_member_initializer_in_member_initializer_list2009);
            	member_initializer244 = member_initializer();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_initializer244.Tree);
            	// G:\\downloads\\antlr\\cs.g:274:22: ( ',' member_initializer )
            	// G:\\downloads\\antlr\\cs.g:274:23: ',' member_initializer
            	{
            		char_literal245=(IToken)Match(input,89,FOLLOW_89_in_member_initializer_list2013); if (state.failed) return retval;
            		if ( state.backtracking == 0 )
            		{char_literal245_tree = (object)adaptor.Create(char_literal245);
            			adaptor.AddChild(root_0, char_literal245_tree);
            		}
            		PushFollow(FOLLOW_member_initializer_in_member_initializer_list2015);
            		member_initializer246 = member_initializer();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_initializer246.Tree);

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 62, member_initializer_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "member_initializer_list"

    public class member_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "member_initializer"
    // G:\\downloads\\antlr\\cs.g:275:1: member_initializer : identifier '=' initializer_value ;
    public csParser.member_initializer_return member_initializer() // throws RecognitionException [1]
    {   
        csParser.member_initializer_return retval = new csParser.member_initializer_return();
        retval.Start = input.LT(1);
        int member_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal248 = null;
        csParser.identifier_return identifier247 = default(csParser.identifier_return);

        csParser.initializer_value_return initializer_value249 = default(csParser.initializer_value_return);


        object char_literal248_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 63) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:275:19: ( identifier '=' initializer_value )
            // G:\\downloads\\antlr\\cs.g:276:2: identifier '=' initializer_value
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_member_initializer2025);
            	identifier247 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier247.Tree);
            	char_literal248=(IToken)Match(input,66,FOLLOW_66_in_member_initializer2029); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal248_tree = (object)adaptor.Create(char_literal248);
            		adaptor.AddChild(root_0, char_literal248_tree);
            	}
            	PushFollow(FOLLOW_initializer_value_in_member_initializer2033);
            	initializer_value249 = initializer_value();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, initializer_value249.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 63, member_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "member_initializer"

    public class initializer_value_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "initializer_value"
    // G:\\downloads\\antlr\\cs.g:277:1: initializer_value : ( expression | object_or_collection_initializer );
    public csParser.initializer_value_return initializer_value() // throws RecognitionException [1]
    {   
        csParser.initializer_value_return retval = new csParser.initializer_value_return();
        retval.Start = input.LT(1);
        int initializer_value_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression250 = default(csParser.expression_return);

        csParser.object_or_collection_initializer_return object_or_collection_initializer251 = default(csParser.object_or_collection_initializer_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 64) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:277:18: ( expression | object_or_collection_initializer )
            int alt70 = 2;
            int LA70_0 = input.LA(1);

            if ( ((LA70_0 >= IDENTIFIER && LA70_0 <= NULL) || LA70_0 == MINUS || LA70_0 == 65 || LA70_0 == 68 || LA70_0 == 83 || LA70_0 == 85 || LA70_0 == 88 || (LA70_0 >= 93 && LA70_0 <= 98) || LA70_0 == 100 || (LA70_0 >= 102 && LA70_0 <= 106) || LA70_0 == 117 || (LA70_0 >= 132 && LA70_0 <= 133) || (LA70_0 >= 135 && LA70_0 <= 148) || (LA70_0 >= 150 && LA70_0 <= 152) || LA70_0 == 154 || (LA70_0 >= 157 && LA70_0 <= 168) || LA70_0 == 170 || (LA70_0 >= 177 && LA70_0 <= 178) || (LA70_0 >= 195 && LA70_0 <= 202)) )
            {
                alt70 = 1;
            }
            else if ( (LA70_0 == 62) )
            {
                alt70 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d70s0 =
                    new NoViableAltException("", 70, 0, input);

                throw nvae_d70s0;
            }
            switch (alt70) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:278:2: expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_in_initializer_value2042);
                    	expression250 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression250.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:279:4: object_or_collection_initializer
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_object_or_collection_initializer_in_initializer_value2048);
                    	object_or_collection_initializer251 = object_or_collection_initializer();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, object_or_collection_initializer251.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 64, initializer_value_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "initializer_value"

    public class typeof_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "typeof_expression"
    // G:\\downloads\\antlr\\cs.g:283:1: typeof_expression : 'typeof' '(' ( ( unbound_type_name )=> unbound_type_name | type | 'void' ) ')' ;
    public csParser.typeof_expression_return typeof_expression() // throws RecognitionException [1]
    {   
        csParser.typeof_expression_return retval = new csParser.typeof_expression_return();
        retval.Start = input.LT(1);
        int typeof_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal252 = null;
        IToken char_literal253 = null;
        IToken string_literal256 = null;
        IToken char_literal257 = null;
        csParser.unbound_type_name_return unbound_type_name254 = default(csParser.unbound_type_name_return);

        csParser.type_return type255 = default(csParser.type_return);


        object string_literal252_tree=null;
        object char_literal253_tree=null;
        object string_literal256_tree=null;
        object char_literal257_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 65) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:283:18: ( 'typeof' '(' ( ( unbound_type_name )=> unbound_type_name | type | 'void' ) ')' )
            // G:\\downloads\\antlr\\cs.g:284:2: 'typeof' '(' ( ( unbound_type_name )=> unbound_type_name | type | 'void' ) ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal252=(IToken)Match(input,98,FOLLOW_98_in_typeof_expression2060); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal252_tree = (object)adaptor.Create(string_literal252);
            		adaptor.AddChild(root_0, string_literal252_tree);
            	}
            	char_literal253=(IToken)Match(input,88,FOLLOW_88_in_typeof_expression2064); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal253_tree = (object)adaptor.Create(char_literal253);
            		adaptor.AddChild(root_0, char_literal253_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:284:19: ( ( unbound_type_name )=> unbound_type_name | type | 'void' )
            	int alt71 = 3;
            	alt71 = dfa71.Predict(input);
            	switch (alt71) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:284:20: ( unbound_type_name )=> unbound_type_name
            	        {
            	        	PushFollow(FOLLOW_unbound_type_name_in_typeof_expression2075);
            	        	unbound_type_name254 = unbound_type_name();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name254.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:285:10: type
            	        {
            	        	PushFollow(FOLLOW_type_in_typeof_expression2086);
            	        	type255 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type255.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // G:\\downloads\\antlr\\cs.g:286:10: 'void'
            	        {
            	        	string_literal256=(IToken)Match(input,82,FOLLOW_82_in_typeof_expression2098); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal256_tree = (object)adaptor.Create(string_literal256);
            	        		adaptor.AddChild(root_0, string_literal256_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal257=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_typeof_expression2103); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal257_tree = (object)adaptor.Create(char_literal257);
            		adaptor.AddChild(root_0, char_literal257_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 65, typeof_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "typeof_expression"

    public class unbound_type_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unbound_type_name"
    // G:\\downloads\\antlr\\cs.g:291:1: unbound_type_name : unbound_type_name_start ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )* generic_dimension_specifier ;
    public csParser.unbound_type_name_return unbound_type_name() // throws RecognitionException [1]
    {   
        csParser.unbound_type_name_return retval = new csParser.unbound_type_name_return();
        retval.Start = input.LT(1);
        int unbound_type_name_StartIndex = input.Index();
        object root_0 = null;

        csParser.unbound_type_name_start_return unbound_type_name_start258 = default(csParser.unbound_type_name_start_return);

        csParser.generic_dimension_specifier_return generic_dimension_specifier259 = default(csParser.generic_dimension_specifier_return);

        csParser.unbound_type_name_part_return unbound_type_name_part260 = default(csParser.unbound_type_name_part_return);

        csParser.unbound_type_name_part_return unbound_type_name_part261 = default(csParser.unbound_type_name_part_return);

        csParser.generic_dimension_specifier_return generic_dimension_specifier262 = default(csParser.generic_dimension_specifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 66) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:291:18: ( unbound_type_name_start ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )* generic_dimension_specifier )
            // G:\\downloads\\antlr\\cs.g:293:2: unbound_type_name_start ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )* generic_dimension_specifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_unbound_type_name_start_in_unbound_type_name2118);
            	unbound_type_name_start258 = unbound_type_name_start();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name_start258.Tree);
            	// G:\\downloads\\antlr\\cs.g:294:3: ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )*
            	do 
            	{
            	    int alt72 = 3;
            	    alt72 = dfa72.Predict(input);
            	    switch (alt72) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:294:4: ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part )
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:294:4: ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part )
            			    	// G:\\downloads\\antlr\\cs.g:294:5: ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part
            			    	{
            			    		PushFollow(FOLLOW_generic_dimension_specifier_in_unbound_type_name2137);
            			    		generic_dimension_specifier259 = generic_dimension_specifier();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_dimension_specifier259.Tree);
            			    		PushFollow(FOLLOW_unbound_type_name_part_in_unbound_type_name2141);
            			    		unbound_type_name_part260 = unbound_type_name_part();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name_part260.Tree);

            			    	}


            			    }
            			    break;
            			case 2 :
            			    // G:\\downloads\\antlr\\cs.g:295:5: unbound_type_name_part
            			    {
            			    	PushFollow(FOLLOW_unbound_type_name_part_in_unbound_type_name2148);
            			    	unbound_type_name_part261 = unbound_type_name_part();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unbound_type_name_part261.Tree);

            			    }
            			    break;

            			default:
            			    goto loop72;
            	    }
            	} while (true);

            	loop72:
            		;	// Stops C# compiler whining that label 'loop72' has no statements

            	PushFollow(FOLLOW_generic_dimension_specifier_in_unbound_type_name2158);
            	generic_dimension_specifier262 = generic_dimension_specifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_dimension_specifier262.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 66, unbound_type_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unbound_type_name"

    public class unbound_type_name_start_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unbound_type_name_start"
    // G:\\downloads\\antlr\\cs.g:299:1: unbound_type_name_start : identifier ( '::' identifier )? ;
    public csParser.unbound_type_name_start_return unbound_type_name_start() // throws RecognitionException [1]
    {   
        csParser.unbound_type_name_start_return retval = new csParser.unbound_type_name_start_return();
        retval.Start = input.LT(1);
        int unbound_type_name_start_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal264 = null;
        csParser.identifier_return identifier263 = default(csParser.identifier_return);

        csParser.identifier_return identifier265 = default(csParser.identifier_return);


        object string_literal264_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 67) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:299:24: ( identifier ( '::' identifier )? )
            // G:\\downloads\\antlr\\cs.g:300:2: identifier ( '::' identifier )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_unbound_type_name_start2168);
            	identifier263 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier263.Tree);
            	// G:\\downloads\\antlr\\cs.g:300:13: ( '::' identifier )?
            	int alt73 = 2;
            	int LA73_0 = input.LA(1);

            	if ( (LA73_0 == 84) )
            	{
            	    alt73 = 1;
            	}
            	switch (alt73) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:300:14: '::' identifier
            	        {
            	        	string_literal264=(IToken)Match(input,84,FOLLOW_84_in_unbound_type_name_start2171); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal264_tree = (object)adaptor.Create(string_literal264);
            	        		adaptor.AddChild(root_0, string_literal264_tree);
            	        	}
            	        	PushFollow(FOLLOW_identifier_in_unbound_type_name_start2173);
            	        	identifier265 = identifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier265.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 67, unbound_type_name_start_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unbound_type_name_start"

    public class unbound_type_name_part_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unbound_type_name_part"
    // G:\\downloads\\antlr\\cs.g:301:1: unbound_type_name_part : '.' identifier ;
    public csParser.unbound_type_name_part_return unbound_type_name_part() // throws RecognitionException [1]
    {   
        csParser.unbound_type_name_part_return retval = new csParser.unbound_type_name_part_return();
        retval.Start = input.LT(1);
        int unbound_type_name_part_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal266 = null;
        csParser.identifier_return identifier267 = default(csParser.identifier_return);


        object char_literal266_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 68) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:301:23: ( '.' identifier )
            // G:\\downloads\\antlr\\cs.g:302:2: '.' identifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal266=(IToken)Match(input,DOT,FOLLOW_DOT_in_unbound_type_name_part2182); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal266_tree = (object)adaptor.Create(char_literal266);
            		adaptor.AddChild(root_0, char_literal266_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_unbound_type_name_part2186);
            	identifier267 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier267.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 68, unbound_type_name_part_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unbound_type_name_part"

    public class generic_dimension_specifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "generic_dimension_specifier"
    // G:\\downloads\\antlr\\cs.g:303:1: generic_dimension_specifier : '<' ( commas )? '>' ;
    public csParser.generic_dimension_specifier_return generic_dimension_specifier() // throws RecognitionException [1]
    {   
        csParser.generic_dimension_specifier_return retval = new csParser.generic_dimension_specifier_return();
        retval.Start = input.LT(1);
        int generic_dimension_specifier_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal268 = null;
        IToken char_literal270 = null;
        csParser.commas_return commas269 = default(csParser.commas_return);


        object char_literal268_tree=null;
        object char_literal270_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 69) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:303:28: ( '<' ( commas )? '>' )
            // G:\\downloads\\antlr\\cs.g:304:2: '<' ( commas )? '>'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal268=(IToken)Match(input,99,FOLLOW_99_in_generic_dimension_specifier2194); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal268_tree = (object)adaptor.Create(char_literal268);
            		adaptor.AddChild(root_0, char_literal268_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:304:8: ( commas )?
            	int alt74 = 2;
            	int LA74_0 = input.LA(1);

            	if ( (LA74_0 == 89) )
            	{
            	    alt74 = 1;
            	}
            	switch (alt74) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:304:8: commas
            	        {
            	        	PushFollow(FOLLOW_commas_in_generic_dimension_specifier2198);
            	        	commas269 = commas();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, commas269.Tree);

            	        }
            	        break;

            	}

            	char_literal270=(IToken)Match(input,GT,FOLLOW_GT_in_generic_dimension_specifier2203); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal270_tree = (object)adaptor.Create(char_literal270);
            		adaptor.AddChild(root_0, char_literal270_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 69, generic_dimension_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "generic_dimension_specifier"

    public class commas_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "commas"
    // G:\\downloads\\antlr\\cs.g:305:1: commas : ( ',' )+ ;
    public csParser.commas_return commas() // throws RecognitionException [1]
    {   
        csParser.commas_return retval = new csParser.commas_return();
        retval.Start = input.LT(1);
        int commas_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal271 = null;

        object char_literal271_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 70) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:305:7: ( ( ',' )+ )
            // G:\\downloads\\antlr\\cs.g:306:2: ( ',' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:306:2: ( ',' )+
            	int cnt75 = 0;
            	do 
            	{
            	    int alt75 = 2;
            	    int LA75_0 = input.LA(1);

            	    if ( (LA75_0 == 89) )
            	    {
            	        alt75 = 1;
            	    }


            	    switch (alt75) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:306:2: ','
            			    {
            			    	char_literal271=(IToken)Match(input,89,FOLLOW_89_in_commas2212); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal271_tree = (object)adaptor.Create(char_literal271);
            			    		adaptor.AddChild(root_0, char_literal271_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt75 >= 1 ) goto loop75;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(75, input);
            		            throw eee;
            	    }
            	    cnt75++;
            	} while (true);

            	loop75:
            		;	// Stops C# compiler whinging that label 'loop75' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 70, commas_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "commas"

    public class type_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_name"
    // G:\\downloads\\antlr\\cs.g:312:1: type_name : namespace_or_type_name ;
    public csParser.type_name_return type_name() // throws RecognitionException [1]
    {   
        csParser.type_name_return retval = new csParser.type_name_return();
        retval.Start = input.LT(1);
        int type_name_StartIndex = input.Index();
        object root_0 = null;

        csParser.namespace_or_type_name_return namespace_or_type_name272 = default(csParser.namespace_or_type_name_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 71) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:312:10: ( namespace_or_type_name )
            // G:\\downloads\\antlr\\cs.g:313:2: namespace_or_type_name
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_namespace_or_type_name_in_type_name2228);
            	namespace_or_type_name272 = namespace_or_type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, namespace_or_type_name272.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 71, type_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_name"

    public class namespace_or_type_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "namespace_or_type_name"
    // G:\\downloads\\antlr\\cs.g:314:1: namespace_or_type_name : type_or_generic ( '::' type_or_generic )? ( '.' type_or_generic )* ;
    public csParser.namespace_or_type_name_return namespace_or_type_name() // throws RecognitionException [1]
    {   
        csParser.namespace_or_type_name_return retval = new csParser.namespace_or_type_name_return();
        retval.Start = input.LT(1);
        int namespace_or_type_name_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal274 = null;
        IToken char_literal276 = null;
        csParser.type_or_generic_return type_or_generic273 = default(csParser.type_or_generic_return);

        csParser.type_or_generic_return type_or_generic275 = default(csParser.type_or_generic_return);

        csParser.type_or_generic_return type_or_generic277 = default(csParser.type_or_generic_return);


        object string_literal274_tree=null;
        object char_literal276_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 72) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:314:23: ( type_or_generic ( '::' type_or_generic )? ( '.' type_or_generic )* )
            // G:\\downloads\\antlr\\cs.g:315:3: type_or_generic ( '::' type_or_generic )? ( '.' type_or_generic )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_or_generic_in_namespace_or_type_name2237);
            	type_or_generic273 = type_or_generic();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic273.Tree);
            	// G:\\downloads\\antlr\\cs.g:315:21: ( '::' type_or_generic )?
            	int alt76 = 2;
            	int LA76_0 = input.LA(1);

            	if ( (LA76_0 == 84) )
            	{
            	    alt76 = 1;
            	}
            	switch (alt76) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:315:22: '::' type_or_generic
            	        {
            	        	string_literal274=(IToken)Match(input,84,FOLLOW_84_in_namespace_or_type_name2242); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal274_tree = (object)adaptor.Create(string_literal274);
            	        		adaptor.AddChild(root_0, string_literal274_tree);
            	        	}
            	        	PushFollow(FOLLOW_type_or_generic_in_namespace_or_type_name2244);
            	        	type_or_generic275 = type_or_generic();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic275.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:315:45: ( '.' type_or_generic )*
            	do 
            	{
            	    int alt77 = 2;
            	    int LA77_0 = input.LA(1);

            	    if ( (LA77_0 == DOT) )
            	    {
            	        int LA77_2 = input.LA(2);

            	        if ( (LA77_2 == IDENTIFIER || LA77_2 == 65 || (LA77_2 >= 132 && LA77_2 <= 133) || (LA77_2 >= 135 && LA77_2 <= 148) || (LA77_2 >= 150 && LA77_2 <= 152) || LA77_2 == 154 || (LA77_2 >= 157 && LA77_2 <= 159) || LA77_2 == 170 || (LA77_2 >= 177 && LA77_2 <= 178) || LA77_2 == 195 || LA77_2 == 202) )
            	        {
            	            alt77 = 1;
            	        }


            	    }


            	    switch (alt77) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:315:46: '.' type_or_generic
            			    {
            			    	char_literal276=(IToken)Match(input,DOT,FOLLOW_DOT_in_namespace_or_type_name2249); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal276_tree = (object)adaptor.Create(char_literal276);
            			    		adaptor.AddChild(root_0, char_literal276_tree);
            			    	}
            			    	PushFollow(FOLLOW_type_or_generic_in_namespace_or_type_name2253);
            			    	type_or_generic277 = type_or_generic();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic277.Tree);

            			    }
            			    break;

            			default:
            			    goto loop77;
            	    }
            	} while (true);

            	loop77:
            		;	// Stops C# compiler whining that label 'loop77' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 72, namespace_or_type_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "namespace_or_type_name"

    public class type_or_generic_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_or_generic"
    // G:\\downloads\\antlr\\cs.g:316:1: type_or_generic : ( ( identifier '<' )=> identifier generic_argument_list | identifier );
    public csParser.type_or_generic_return type_or_generic() // throws RecognitionException [1]
    {   
        csParser.type_or_generic_return retval = new csParser.type_or_generic_return();
        retval.Start = input.LT(1);
        int type_or_generic_StartIndex = input.Index();
        object root_0 = null;

        csParser.identifier_return identifier278 = default(csParser.identifier_return);

        csParser.generic_argument_list_return generic_argument_list279 = default(csParser.generic_argument_list_return);

        csParser.identifier_return identifier280 = default(csParser.identifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 73) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:316:16: ( ( identifier '<' )=> identifier generic_argument_list | identifier )
            int alt78 = 2;
            int LA78_0 = input.LA(1);

            if ( (LA78_0 == IDENTIFIER || LA78_0 == 65 || (LA78_0 >= 132 && LA78_0 <= 133) || (LA78_0 >= 135 && LA78_0 <= 148) || (LA78_0 >= 150 && LA78_0 <= 152) || LA78_0 == 154 || (LA78_0 >= 157 && LA78_0 <= 159) || LA78_0 == 170 || (LA78_0 >= 177 && LA78_0 <= 178) || LA78_0 == 195 || LA78_0 == 202) )
            {
                int LA78_1 = input.LA(2);

                if ( (synpred15_cs()) )
                {
                    alt78 = 1;
                }
                else if ( (true) )
                {
                    alt78 = 2;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d78s1 =
                        new NoViableAltException("", 78, 1, input);

                    throw nvae_d78s1;
                }
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d78s0 =
                    new NoViableAltException("", 78, 0, input);

                throw nvae_d78s0;
            }
            switch (alt78) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:317:2: ( identifier '<' )=> identifier generic_argument_list
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_type_or_generic2273);
                    	identifier278 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier278.Tree);
                    	PushFollow(FOLLOW_generic_argument_list_in_type_or_generic2277);
                    	generic_argument_list279 = generic_argument_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list279.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:318:4: identifier
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_type_or_generic2282);
                    	identifier280 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier280.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 73, type_or_generic_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_or_generic"

    public class qid_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "qid"
    // G:\\downloads\\antlr\\cs.g:320:1: qid : qid_start ( qid_part )* ;
    public csParser.qid_return qid() // throws RecognitionException [1]
    {   
        csParser.qid_return retval = new csParser.qid_return();
        retval.Start = input.LT(1);
        int qid_StartIndex = input.Index();
        object root_0 = null;

        csParser.qid_start_return qid_start281 = default(csParser.qid_start_return);

        csParser.qid_part_return qid_part282 = default(csParser.qid_part_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 74) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:320:4: ( qid_start ( qid_part )* )
            // G:\\downloads\\antlr\\cs.g:321:2: qid_start ( qid_part )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_qid_start_in_qid2293);
            	qid_start281 = qid_start();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qid_start281.Tree);
            	// G:\\downloads\\antlr\\cs.g:321:14: ( qid_part )*
            	do 
            	{
            	    int alt79 = 2;
            	    int LA79_0 = input.LA(1);

            	    if ( (LA79_0 == DOT) )
            	    {
            	        int LA79_2 = input.LA(2);

            	        if ( (LA79_2 == IDENTIFIER || LA79_2 == 65 || (LA79_2 >= 132 && LA79_2 <= 133) || (LA79_2 >= 135 && LA79_2 <= 148) || (LA79_2 >= 150 && LA79_2 <= 152) || LA79_2 == 154 || (LA79_2 >= 157 && LA79_2 <= 159) || LA79_2 == 170 || (LA79_2 >= 177 && LA79_2 <= 178) || LA79_2 == 195 || LA79_2 == 202) )
            	        {
            	            alt79 = 1;
            	        }


            	    }
            	    else if ( (LA79_0 == PTR) )
            	    {
            	        alt79 = 1;
            	    }


            	    switch (alt79) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:321:14: qid_part
            			    {
            			    	PushFollow(FOLLOW_qid_part_in_qid2297);
            			    	qid_part282 = qid_part();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qid_part282.Tree);

            			    }
            			    break;

            			default:
            			    goto loop79;
            	    }
            	} while (true);

            	loop79:
            		;	// Stops C# compiler whining that label 'loop79' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 74, qid_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "qid"

    public class qid_start_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "qid_start"
    // G:\\downloads\\antlr\\cs.g:323:1: qid_start : ( predefined_type | ( identifier '<' )=> identifier generic_argument_list | identifier ( '::' identifier )? | literal );
    public csParser.qid_start_return qid_start() // throws RecognitionException [1]
    {   
        csParser.qid_start_return retval = new csParser.qid_start_return();
        retval.Start = input.LT(1);
        int qid_start_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal287 = null;
        csParser.predefined_type_return predefined_type283 = default(csParser.predefined_type_return);

        csParser.identifier_return identifier284 = default(csParser.identifier_return);

        csParser.generic_argument_list_return generic_argument_list285 = default(csParser.generic_argument_list_return);

        csParser.identifier_return identifier286 = default(csParser.identifier_return);

        csParser.identifier_return identifier288 = default(csParser.identifier_return);

        csParser.literal_return literal289 = default(csParser.literal_return);


        object string_literal287_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 75) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:323:10: ( predefined_type | ( identifier '<' )=> identifier generic_argument_list | identifier ( '::' identifier )? | literal )
            int alt81 = 4;
            switch ( input.LA(1) ) 
            {
            case 160:
            case 161:
            case 162:
            case 163:
            case 164:
            case 165:
            case 166:
            case 167:
            case 168:
            case 196:
            case 197:
            case 198:
            case 199:
            case 200:
            case 201:
            	{
                alt81 = 1;
                }
                break;
            case IDENTIFIER:
            case 65:
            case 132:
            case 133:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 170:
            case 177:
            case 178:
            case 195:
            case 202:
            	{
                int LA81_2 = input.LA(2);

                if ( (LA81_2 == 99) && (synpred16_cs()) )
                {
                    alt81 = 2;
                }
                else if ( ((LA81_2 >= DOT && LA81_2 <= PTR) || LA81_2 == 62 || LA81_2 == 84 || LA81_2 == 88) )
                {
                    alt81 = 3;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d81s2 =
                        new NoViableAltException("", 81, 2, input);

                    throw nvae_d81s2;
                }
                }
                break;
            case Real_literal:
            case NUMBER:
            case Hex_number:
            case Character_literal:
            case STRINGLITERAL:
            case Verbatim_string_literal:
            case TRUE:
            case FALSE:
            case NULL:
            	{
                alt81 = 4;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d81s0 =
            	        new NoViableAltException("", 81, 0, input);

            	    throw nvae_d81s0;
            }

            switch (alt81) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:324:2: predefined_type
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_predefined_type_in_qid_start2307);
                    	predefined_type283 = predefined_type();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type283.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:325:4: ( identifier '<' )=> identifier generic_argument_list
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_qid_start2323);
                    	identifier284 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier284.Tree);
                    	PushFollow(FOLLOW_generic_argument_list_in_qid_start2327);
                    	generic_argument_list285 = generic_argument_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list285.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:328:4: identifier ( '::' identifier )?
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_qid_start2334);
                    	identifier286 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier286.Tree);
                    	// G:\\downloads\\antlr\\cs.g:328:17: ( '::' identifier )?
                    	int alt80 = 2;
                    	int LA80_0 = input.LA(1);

                    	if ( (LA80_0 == 84) )
                    	{
                    	    alt80 = 1;
                    	}
                    	switch (alt80) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:328:18: '::' identifier
                    	        {
                    	        	string_literal287=(IToken)Match(input,84,FOLLOW_84_in_qid_start2339); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{string_literal287_tree = (object)adaptor.Create(string_literal287);
                    	        		adaptor.AddChild(root_0, string_literal287_tree);
                    	        	}
                    	        	PushFollow(FOLLOW_identifier_in_qid_start2343);
                    	        	identifier288 = identifier();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier288.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:329:4: literal
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_literal_in_qid_start2350);
                    	literal289 = literal();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal289.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 75, qid_start_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "qid_start"

    public class qid_part_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "qid_part"
    // G:\\downloads\\antlr\\cs.g:333:1: qid_part : access_identifier ;
    public csParser.qid_part_return qid_part() // throws RecognitionException [1]
    {   
        csParser.qid_part_return retval = new csParser.qid_part_return();
        retval.Start = input.LT(1);
        int qid_part_StartIndex = input.Index();
        object root_0 = null;

        csParser.access_identifier_return access_identifier290 = default(csParser.access_identifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 76) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:333:9: ( access_identifier )
            // G:\\downloads\\antlr\\cs.g:334:2: access_identifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_access_identifier_in_qid_part2364);
            	access_identifier290 = access_identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_identifier290.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 76, qid_part_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "qid_part"

    public class generic_argument_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "generic_argument_list"
    // G:\\downloads\\antlr\\cs.g:336:1: generic_argument_list : '<' type_arguments '>' ;
    public csParser.generic_argument_list_return generic_argument_list() // throws RecognitionException [1]
    {   
        csParser.generic_argument_list_return retval = new csParser.generic_argument_list_return();
        retval.Start = input.LT(1);
        int generic_argument_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal291 = null;
        IToken char_literal293 = null;
        csParser.type_arguments_return type_arguments292 = default(csParser.type_arguments_return);


        object char_literal291_tree=null;
        object char_literal293_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 77) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:336:22: ( '<' type_arguments '>' )
            // G:\\downloads\\antlr\\cs.g:337:2: '<' type_arguments '>'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal291=(IToken)Match(input,99,FOLLOW_99_in_generic_argument_list2374); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal291_tree = (object)adaptor.Create(char_literal291);
            		adaptor.AddChild(root_0, char_literal291_tree);
            	}
            	PushFollow(FOLLOW_type_arguments_in_generic_argument_list2378);
            	type_arguments292 = type_arguments();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_arguments292.Tree);
            	char_literal293=(IToken)Match(input,GT,FOLLOW_GT_in_generic_argument_list2382); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal293_tree = (object)adaptor.Create(char_literal293);
            		adaptor.AddChild(root_0, char_literal293_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 77, generic_argument_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "generic_argument_list"

    public class type_arguments_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_arguments"
    // G:\\downloads\\antlr\\cs.g:338:1: type_arguments : type ( ',' type )* ;
    public csParser.type_arguments_return type_arguments() // throws RecognitionException [1]
    {   
        csParser.type_arguments_return retval = new csParser.type_arguments_return();
        retval.Start = input.LT(1);
        int type_arguments_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal295 = null;
        csParser.type_return type294 = default(csParser.type_return);

        csParser.type_return type296 = default(csParser.type_return);


        object char_literal295_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 78) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:338:15: ( type ( ',' type )* )
            // G:\\downloads\\antlr\\cs.g:339:2: type ( ',' type )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_type_arguments2391);
            	type294 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type294.Tree);
            	// G:\\downloads\\antlr\\cs.g:339:7: ( ',' type )*
            	do 
            	{
            	    int alt82 = 2;
            	    int LA82_0 = input.LA(1);

            	    if ( (LA82_0 == 89) )
            	    {
            	        alt82 = 1;
            	    }


            	    switch (alt82) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:339:8: ',' type
            			    {
            			    	char_literal295=(IToken)Match(input,89,FOLLOW_89_in_type_arguments2394); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal295_tree = (object)adaptor.Create(char_literal295);
            			    		adaptor.AddChild(root_0, char_literal295_tree);
            			    	}
            			    	PushFollow(FOLLOW_type_in_type_arguments2396);
            			    	type296 = type();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type296.Tree);

            			    }
            			    break;

            			default:
            			    goto loop82;
            	    }
            	} while (true);

            	loop82:
            		;	// Stops C# compiler whining that label 'loop82' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 78, type_arguments_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_arguments"

    public class type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type"
    // G:\\downloads\\antlr\\cs.g:341:1: type : ( ( ( predefined_type | type_name ) rank_specifiers )=> ( predefined_type | type_name ) rank_specifiers ( '*' )* | ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )=> ( predefined_type | type_name ) ( ( '*' )+ | '?' ) | ( predefined_type | type_name ) | 'void' ( '*' )+ );
    public csParser.type_return type() // throws RecognitionException [1]
    {   
        csParser.type_return retval = new csParser.type_return();
        retval.Start = input.LT(1);
        int type_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal300 = null;
        IToken char_literal303 = null;
        IToken char_literal304 = null;
        IToken string_literal307 = null;
        IToken char_literal308 = null;
        csParser.predefined_type_return predefined_type297 = default(csParser.predefined_type_return);

        csParser.type_name_return type_name298 = default(csParser.type_name_return);

        csParser.rank_specifiers_return rank_specifiers299 = default(csParser.rank_specifiers_return);

        csParser.predefined_type_return predefined_type301 = default(csParser.predefined_type_return);

        csParser.type_name_return type_name302 = default(csParser.type_name_return);

        csParser.predefined_type_return predefined_type305 = default(csParser.predefined_type_return);

        csParser.type_name_return type_name306 = default(csParser.type_name_return);


        object char_literal300_tree=null;
        object char_literal303_tree=null;
        object char_literal304_tree=null;
        object string_literal307_tree=null;
        object char_literal308_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 79) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:341:5: ( ( ( predefined_type | type_name ) rank_specifiers )=> ( predefined_type | type_name ) rank_specifiers ( '*' )* | ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )=> ( predefined_type | type_name ) ( ( '*' )+ | '?' ) | ( predefined_type | type_name ) | 'void' ( '*' )+ )
            int alt90 = 4;
            switch ( input.LA(1) ) 
            {
            case 160:
            case 161:
            case 162:
            case 163:
            case 164:
            case 165:
            case 166:
            case 167:
            case 168:
            case 196:
            case 197:
            case 198:
            case 199:
            case 200:
            case 201:
            	{
                int LA90_1 = input.LA(2);

                if ( (synpred17_cs()) )
                {
                    alt90 = 1;
                }
                else if ( (synpred18_cs()) )
                {
                    alt90 = 2;
                }
                else if ( (true) )
                {
                    alt90 = 3;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d90s1 =
                        new NoViableAltException("", 90, 1, input);

                    throw nvae_d90s1;
                }
                }
                break;
            case IDENTIFIER:
            case 65:
            case 132:
            case 133:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 170:
            case 177:
            case 178:
            case 195:
            case 202:
            	{
                int LA90_2 = input.LA(2);

                if ( (synpred17_cs()) )
                {
                    alt90 = 1;
                }
                else if ( (synpred18_cs()) )
                {
                    alt90 = 2;
                }
                else if ( (true) )
                {
                    alt90 = 3;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d90s2 =
                        new NoViableAltException("", 90, 2, input);

                    throw nvae_d90s2;
                }
                }
                break;
            case 82:
            	{
                alt90 = 4;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d90s0 =
            	        new NoViableAltException("", 90, 0, input);

            	    throw nvae_d90s0;
            }

            switch (alt90) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:342:4: ( ( predefined_type | type_name ) rank_specifiers )=> ( predefined_type | type_name ) rank_specifiers ( '*' )*
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:342:56: ( predefined_type | type_name )
                    	int alt83 = 2;
                    	int LA83_0 = input.LA(1);

                    	if ( ((LA83_0 >= 160 && LA83_0 <= 168) || (LA83_0 >= 196 && LA83_0 <= 201)) )
                    	{
                    	    alt83 = 1;
                    	}
                    	else if ( (LA83_0 == IDENTIFIER || LA83_0 == 65 || (LA83_0 >= 132 && LA83_0 <= 133) || (LA83_0 >= 135 && LA83_0 <= 148) || (LA83_0 >= 150 && LA83_0 <= 152) || LA83_0 == 154 || (LA83_0 >= 157 && LA83_0 <= 159) || LA83_0 == 170 || (LA83_0 >= 177 && LA83_0 <= 178) || LA83_0 == 195 || LA83_0 == 202) )
                    	{
                    	    alt83 = 2;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d83s0 =
                    	        new NoViableAltException("", 83, 0, input);

                    	    throw nvae_d83s0;
                    	}
                    	switch (alt83) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:342:57: predefined_type
                    	        {
                    	        	PushFollow(FOLLOW_predefined_type_in_type2425);
                    	        	predefined_type297 = predefined_type();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type297.Tree);

                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:342:75: type_name
                    	        {
                    	        	PushFollow(FOLLOW_type_name_in_type2429);
                    	        	type_name298 = type_name();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name298.Tree);

                    	        }
                    	        break;

                    	}

                    	PushFollow(FOLLOW_rank_specifiers_in_type2434);
                    	rank_specifiers299 = rank_specifiers();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifiers299.Tree);
                    	// G:\\downloads\\antlr\\cs.g:342:106: ( '*' )*
                    	do 
                    	{
                    	    int alt84 = 2;
                    	    int LA84_0 = input.LA(1);

                    	    if ( (LA84_0 == 100) )
                    	    {
                    	        alt84 = 1;
                    	    }


                    	    switch (alt84) 
                    		{
                    			case 1 :
                    			    // G:\\downloads\\antlr\\cs.g:342:106: '*'
                    			    {
                    			    	char_literal300=(IToken)Match(input,100,FOLLOW_100_in_type2438); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{char_literal300_tree = (object)adaptor.Create(char_literal300);
                    			    		adaptor.AddChild(root_0, char_literal300_tree);
                    			    	}

                    			    }
                    			    break;

                    			default:
                    			    goto loop84;
                    	    }
                    	} while (true);

                    	loop84:
                    		;	// Stops C# compiler whining that label 'loop84' has no statements


                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:343:4: ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )=> ( predefined_type | type_name ) ( ( '*' )+ | '?' )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:343:53: ( predefined_type | type_name )
                    	int alt85 = 2;
                    	int LA85_0 = input.LA(1);

                    	if ( ((LA85_0 >= 160 && LA85_0 <= 168) || (LA85_0 >= 196 && LA85_0 <= 201)) )
                    	{
                    	    alt85 = 1;
                    	}
                    	else if ( (LA85_0 == IDENTIFIER || LA85_0 == 65 || (LA85_0 >= 132 && LA85_0 <= 133) || (LA85_0 >= 135 && LA85_0 <= 148) || (LA85_0 >= 150 && LA85_0 <= 152) || LA85_0 == 154 || (LA85_0 >= 157 && LA85_0 <= 159) || LA85_0 == 170 || (LA85_0 >= 177 && LA85_0 <= 178) || LA85_0 == 195 || LA85_0 == 202) )
                    	{
                    	    alt85 = 2;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d85s0 =
                    	        new NoViableAltException("", 85, 0, input);

                    	    throw nvae_d85s0;
                    	}
                    	switch (alt85) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:343:54: predefined_type
                    	        {
                    	        	PushFollow(FOLLOW_predefined_type_in_type2467);
                    	        	predefined_type301 = predefined_type();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type301.Tree);

                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:343:72: type_name
                    	        {
                    	        	PushFollow(FOLLOW_type_name_in_type2471);
                    	        	type_name302 = type_name();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name302.Tree);

                    	        }
                    	        break;

                    	}

                    	// G:\\downloads\\antlr\\cs.g:343:85: ( ( '*' )+ | '?' )
                    	int alt87 = 2;
                    	int LA87_0 = input.LA(1);

                    	if ( (LA87_0 == 100) )
                    	{
                    	    alt87 = 1;
                    	}
                    	else if ( (LA87_0 == 101) )
                    	{
                    	    alt87 = 2;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d87s0 =
                    	        new NoViableAltException("", 87, 0, input);

                    	    throw nvae_d87s0;
                    	}
                    	switch (alt87) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:343:86: ( '*' )+
                    	        {
                    	        	// G:\\downloads\\antlr\\cs.g:343:86: ( '*' )+
                    	        	int cnt86 = 0;
                    	        	do 
                    	        	{
                    	        	    int alt86 = 2;
                    	        	    int LA86_0 = input.LA(1);

                    	        	    if ( (LA86_0 == 100) )
                    	        	    {
                    	        	        alt86 = 1;
                    	        	    }


                    	        	    switch (alt86) 
                    	        		{
                    	        			case 1 :
                    	        			    // G:\\downloads\\antlr\\cs.g:343:86: '*'
                    	        			    {
                    	        			    	char_literal303=(IToken)Match(input,100,FOLLOW_100_in_type2477); if (state.failed) return retval;
                    	        			    	if ( state.backtracking == 0 )
                    	        			    	{char_literal303_tree = (object)adaptor.Create(char_literal303);
                    	        			    		adaptor.AddChild(root_0, char_literal303_tree);
                    	        			    	}

                    	        			    }
                    	        			    break;

                    	        			default:
                    	        			    if ( cnt86 >= 1 ) goto loop86;
                    	        			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	        		            EarlyExitException eee =
                    	        		                new EarlyExitException(86, input);
                    	        		            throw eee;
                    	        	    }
                    	        	    cnt86++;
                    	        	} while (true);

                    	        	loop86:
                    	        		;	// Stops C# compiler whinging that label 'loop86' has no statements


                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:343:93: '?'
                    	        {
                    	        	char_literal304=(IToken)Match(input,101,FOLLOW_101_in_type2482); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{char_literal304_tree = (object)adaptor.Create(char_literal304);
                    	        		adaptor.AddChild(root_0, char_literal304_tree);
                    	        	}

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:344:4: ( predefined_type | type_name )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:344:4: ( predefined_type | type_name )
                    	int alt88 = 2;
                    	int LA88_0 = input.LA(1);

                    	if ( ((LA88_0 >= 160 && LA88_0 <= 168) || (LA88_0 >= 196 && LA88_0 <= 201)) )
                    	{
                    	    alt88 = 1;
                    	}
                    	else if ( (LA88_0 == IDENTIFIER || LA88_0 == 65 || (LA88_0 >= 132 && LA88_0 <= 133) || (LA88_0 >= 135 && LA88_0 <= 148) || (LA88_0 >= 150 && LA88_0 <= 152) || LA88_0 == 154 || (LA88_0 >= 157 && LA88_0 <= 159) || LA88_0 == 170 || (LA88_0 >= 177 && LA88_0 <= 178) || LA88_0 == 195 || LA88_0 == 202) )
                    	{
                    	    alt88 = 2;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d88s0 =
                    	        new NoViableAltException("", 88, 0, input);

                    	    throw nvae_d88s0;
                    	}
                    	switch (alt88) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:344:5: predefined_type
                    	        {
                    	        	PushFollow(FOLLOW_predefined_type_in_type2489);
                    	        	predefined_type305 = predefined_type();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type305.Tree);

                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:344:23: type_name
                    	        {
                    	        	PushFollow(FOLLOW_type_name_in_type2493);
                    	        	type_name306 = type_name();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name306.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:345:4: 'void' ( '*' )+
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal307=(IToken)Match(input,82,FOLLOW_82_in_type2499); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal307_tree = (object)adaptor.Create(string_literal307);
                    		adaptor.AddChild(root_0, string_literal307_tree);
                    	}
                    	// G:\\downloads\\antlr\\cs.g:345:11: ( '*' )+
                    	int cnt89 = 0;
                    	do 
                    	{
                    	    int alt89 = 2;
                    	    int LA89_0 = input.LA(1);

                    	    if ( (LA89_0 == 100) )
                    	    {
                    	        alt89 = 1;
                    	    }


                    	    switch (alt89) 
                    		{
                    			case 1 :
                    			    // G:\\downloads\\antlr\\cs.g:345:11: '*'
                    			    {
                    			    	char_literal308=(IToken)Match(input,100,FOLLOW_100_in_type2501); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{char_literal308_tree = (object)adaptor.Create(char_literal308);
                    			    		adaptor.AddChild(root_0, char_literal308_tree);
                    			    	}

                    			    }
                    			    break;

                    			default:
                    			    if ( cnt89 >= 1 ) goto loop89;
                    			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    		            EarlyExitException eee =
                    		                new EarlyExitException(89, input);
                    		            throw eee;
                    	    }
                    	    cnt89++;
                    	} while (true);

                    	loop89:
                    		;	// Stops C# compiler whinging that label 'loop89' has no statements


                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 79, type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type"

    public class non_nullable_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "non_nullable_type"
    // G:\\downloads\\antlr\\cs.g:347:1: non_nullable_type : ( ( predefined_type | type_name ) ( rank_specifiers ( '*' )* | ( ( '*' )+ )? ) | 'void' ( '*' )+ );
    public csParser.non_nullable_type_return non_nullable_type() // throws RecognitionException [1]
    {   
        csParser.non_nullable_type_return retval = new csParser.non_nullable_type_return();
        retval.Start = input.LT(1);
        int non_nullable_type_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal312 = null;
        IToken char_literal313 = null;
        IToken string_literal314 = null;
        IToken char_literal315 = null;
        csParser.predefined_type_return predefined_type309 = default(csParser.predefined_type_return);

        csParser.type_name_return type_name310 = default(csParser.type_name_return);

        csParser.rank_specifiers_return rank_specifiers311 = default(csParser.rank_specifiers_return);


        object char_literal312_tree=null;
        object char_literal313_tree=null;
        object string_literal314_tree=null;
        object char_literal315_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 80) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:347:18: ( ( predefined_type | type_name ) ( rank_specifiers ( '*' )* | ( ( '*' )+ )? ) | 'void' ( '*' )+ )
            int alt97 = 2;
            int LA97_0 = input.LA(1);

            if ( (LA97_0 == IDENTIFIER || LA97_0 == 65 || (LA97_0 >= 132 && LA97_0 <= 133) || (LA97_0 >= 135 && LA97_0 <= 148) || (LA97_0 >= 150 && LA97_0 <= 152) || LA97_0 == 154 || (LA97_0 >= 157 && LA97_0 <= 168) || LA97_0 == 170 || (LA97_0 >= 177 && LA97_0 <= 178) || (LA97_0 >= 195 && LA97_0 <= 202)) )
            {
                alt97 = 1;
            }
            else if ( (LA97_0 == 82) )
            {
                alt97 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d97s0 =
                    new NoViableAltException("", 97, 0, input);

                throw nvae_d97s0;
            }
            switch (alt97) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:348:2: ( predefined_type | type_name ) ( rank_specifiers ( '*' )* | ( ( '*' )+ )? )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:348:2: ( predefined_type | type_name )
                    	int alt91 = 2;
                    	int LA91_0 = input.LA(1);

                    	if ( ((LA91_0 >= 160 && LA91_0 <= 168) || (LA91_0 >= 196 && LA91_0 <= 201)) )
                    	{
                    	    alt91 = 1;
                    	}
                    	else if ( (LA91_0 == IDENTIFIER || LA91_0 == 65 || (LA91_0 >= 132 && LA91_0 <= 133) || (LA91_0 >= 135 && LA91_0 <= 148) || (LA91_0 >= 150 && LA91_0 <= 152) || LA91_0 == 154 || (LA91_0 >= 157 && LA91_0 <= 159) || LA91_0 == 170 || (LA91_0 >= 177 && LA91_0 <= 178) || LA91_0 == 195 || LA91_0 == 202) )
                    	{
                    	    alt91 = 2;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d91s0 =
                    	        new NoViableAltException("", 91, 0, input);

                    	    throw nvae_d91s0;
                    	}
                    	switch (alt91) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:348:3: predefined_type
                    	        {
                    	        	PushFollow(FOLLOW_predefined_type_in_non_nullable_type2512);
                    	        	predefined_type309 = predefined_type();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type309.Tree);

                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:348:21: type_name
                    	        {
                    	        	PushFollow(FOLLOW_type_name_in_non_nullable_type2516);
                    	        	type_name310 = type_name();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name310.Tree);

                    	        }
                    	        break;

                    	}

                    	// G:\\downloads\\antlr\\cs.g:349:3: ( rank_specifiers ( '*' )* | ( ( '*' )+ )? )
                    	int alt95 = 2;
                    	int LA95_0 = input.LA(1);

                    	if ( (LA95_0 == 86) )
                    	{
                    	    alt95 = 1;
                    	}
                    	else if ( (LA95_0 == EOF || LA95_0 == IDENTIFIER || LA95_0 == GT || (LA95_0 >= SEMI && LA95_0 <= RPAREN) || LA95_0 == 63 || LA95_0 == 65 || LA95_0 == 87 || (LA95_0 >= 89 && LA95_0 <= 90) || (LA95_0 >= 99 && LA95_0 <= 101) || (LA95_0 >= 116 && LA95_0 <= 117) || (LA95_0 >= 121 && LA95_0 <= 130) || (LA95_0 >= 132 && LA95_0 <= 133) || (LA95_0 >= 135 && LA95_0 <= 148) || (LA95_0 >= 150 && LA95_0 <= 152) || LA95_0 == 154 || (LA95_0 >= 157 && LA95_0 <= 159) || LA95_0 == 170 || (LA95_0 >= 177 && LA95_0 <= 178) || LA95_0 == 195 || LA95_0 == 202) )
                    	{
                    	    alt95 = 2;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d95s0 =
                    	        new NoViableAltException("", 95, 0, input);

                    	    throw nvae_d95s0;
                    	}
                    	switch (alt95) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:349:7: rank_specifiers ( '*' )*
                    	        {
                    	        	PushFollow(FOLLOW_rank_specifiers_in_non_nullable_type2525);
                    	        	rank_specifiers311 = rank_specifiers();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, rank_specifiers311.Tree);
                    	        	// G:\\downloads\\antlr\\cs.g:349:25: ( '*' )*
                    	        	do 
                    	        	{
                    	        	    int alt92 = 2;
                    	        	    int LA92_0 = input.LA(1);

                    	        	    if ( (LA92_0 == 100) )
                    	        	    {
                    	        	        alt92 = 1;
                    	        	    }


                    	        	    switch (alt92) 
                    	        		{
                    	        			case 1 :
                    	        			    // G:\\downloads\\antlr\\cs.g:349:25: '*'
                    	        			    {
                    	        			    	char_literal312=(IToken)Match(input,100,FOLLOW_100_in_non_nullable_type2529); if (state.failed) return retval;
                    	        			    	if ( state.backtracking == 0 )
                    	        			    	{char_literal312_tree = (object)adaptor.Create(char_literal312);
                    	        			    		adaptor.AddChild(root_0, char_literal312_tree);
                    	        			    	}

                    	        			    }
                    	        			    break;

                    	        			default:
                    	        			    goto loop92;
                    	        	    }
                    	        	} while (true);

                    	        	loop92:
                    	        		;	// Stops C# compiler whining that label 'loop92' has no statements


                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:350:6: ( ( '*' )+ )?
                    	        {
                    	        	// G:\\downloads\\antlr\\cs.g:350:6: ( ( '*' )+ )?
                    	        	int alt94 = 2;
                    	        	int LA94_0 = input.LA(1);

                    	        	if ( (LA94_0 == 100) )
                    	        	{
                    	        	    alt94 = 1;
                    	        	}
                    	        	switch (alt94) 
                    	        	{
                    	        	    case 1 :
                    	        	        // G:\\downloads\\antlr\\cs.g:350:7: ( '*' )+
                    	        	        {
                    	        	        	// G:\\downloads\\antlr\\cs.g:350:7: ( '*' )+
                    	        	        	int cnt93 = 0;
                    	        	        	do 
                    	        	        	{
                    	        	        	    int alt93 = 2;
                    	        	        	    int LA93_0 = input.LA(1);

                    	        	        	    if ( (LA93_0 == 100) )
                    	        	        	    {
                    	        	        	        alt93 = 1;
                    	        	        	    }


                    	        	        	    switch (alt93) 
                    	        	        		{
                    	        	        			case 1 :
                    	        	        			    // G:\\downloads\\antlr\\cs.g:350:7: '*'
                    	        	        			    {
                    	        	        			    	char_literal313=(IToken)Match(input,100,FOLLOW_100_in_non_nullable_type2538); if (state.failed) return retval;
                    	        	        			    	if ( state.backtracking == 0 )
                    	        	        			    	{char_literal313_tree = (object)adaptor.Create(char_literal313);
                    	        	        			    		adaptor.AddChild(root_0, char_literal313_tree);
                    	        	        			    	}

                    	        	        			    }
                    	        	        			    break;

                    	        	        			default:
                    	        	        			    if ( cnt93 >= 1 ) goto loop93;
                    	        	        			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	        	        		            EarlyExitException eee =
                    	        	        		                new EarlyExitException(93, input);
                    	        	        		            throw eee;
                    	        	        	    }
                    	        	        	    cnt93++;
                    	        	        	} while (true);

                    	        	        	loop93:
                    	        	        		;	// Stops C# compiler whinging that label 'loop93' has no statements


                    	        	        }
                    	        	        break;

                    	        	}


                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:352:4: 'void' ( '*' )+
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal314=(IToken)Match(input,82,FOLLOW_82_in_non_nullable_type2550); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal314_tree = (object)adaptor.Create(string_literal314);
                    		adaptor.AddChild(root_0, string_literal314_tree);
                    	}
                    	// G:\\downloads\\antlr\\cs.g:352:13: ( '*' )+
                    	int cnt96 = 0;
                    	do 
                    	{
                    	    int alt96 = 2;
                    	    int LA96_0 = input.LA(1);

                    	    if ( (LA96_0 == 100) )
                    	    {
                    	        alt96 = 1;
                    	    }


                    	    switch (alt96) 
                    		{
                    			case 1 :
                    			    // G:\\downloads\\antlr\\cs.g:352:13: '*'
                    			    {
                    			    	char_literal315=(IToken)Match(input,100,FOLLOW_100_in_non_nullable_type2554); if (state.failed) return retval;
                    			    	if ( state.backtracking == 0 )
                    			    	{char_literal315_tree = (object)adaptor.Create(char_literal315);
                    			    		adaptor.AddChild(root_0, char_literal315_tree);
                    			    	}

                    			    }
                    			    break;

                    			default:
                    			    if ( cnt96 >= 1 ) goto loop96;
                    			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    		            EarlyExitException eee =
                    		                new EarlyExitException(96, input);
                    		            throw eee;
                    	    }
                    	    cnt96++;
                    	} while (true);

                    	loop96:
                    		;	// Stops C# compiler whinging that label 'loop96' has no statements


                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 80, non_nullable_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "non_nullable_type"

    public class non_array_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "non_array_type"
    // G:\\downloads\\antlr\\cs.g:354:1: non_array_type : type ;
    public csParser.non_array_type_return non_array_type() // throws RecognitionException [1]
    {   
        csParser.non_array_type_return retval = new csParser.non_array_type_return();
        retval.Start = input.LT(1);
        int non_array_type_StartIndex = input.Index();
        object root_0 = null;

        csParser.type_return type316 = default(csParser.type_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 81) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:354:15: ( type )
            // G:\\downloads\\antlr\\cs.g:355:2: type
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_non_array_type2565);
            	type316 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type316.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 81, non_array_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "non_array_type"

    public class array_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "array_type"
    // G:\\downloads\\antlr\\cs.g:356:1: array_type : type ;
    public csParser.array_type_return array_type() // throws RecognitionException [1]
    {   
        csParser.array_type_return retval = new csParser.array_type_return();
        retval.Start = input.LT(1);
        int array_type_StartIndex = input.Index();
        object root_0 = null;

        csParser.type_return type317 = default(csParser.type_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 82) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:356:11: ( type )
            // G:\\downloads\\antlr\\cs.g:357:2: type
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_array_type2572);
            	type317 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type317.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 82, array_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "array_type"

    public class unmanaged_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unmanaged_type"
    // G:\\downloads\\antlr\\cs.g:358:1: unmanaged_type : type ;
    public csParser.unmanaged_type_return unmanaged_type() // throws RecognitionException [1]
    {   
        csParser.unmanaged_type_return retval = new csParser.unmanaged_type_return();
        retval.Start = input.LT(1);
        int unmanaged_type_StartIndex = input.Index();
        object root_0 = null;

        csParser.type_return type318 = default(csParser.type_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 83) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:358:15: ( type )
            // G:\\downloads\\antlr\\cs.g:359:2: type
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_unmanaged_type2579);
            	type318 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type318.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 83, unmanaged_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unmanaged_type"

    public class class_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "class_type"
    // G:\\downloads\\antlr\\cs.g:360:1: class_type : type ;
    public csParser.class_type_return class_type() // throws RecognitionException [1]
    {   
        csParser.class_type_return retval = new csParser.class_type_return();
        retval.Start = input.LT(1);
        int class_type_StartIndex = input.Index();
        object root_0 = null;

        csParser.type_return type319 = default(csParser.type_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 84) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:360:11: ( type )
            // G:\\downloads\\antlr\\cs.g:361:2: type
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_class_type2586);
            	type319 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type319.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 84, class_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "class_type"

    public class pointer_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "pointer_type"
    // G:\\downloads\\antlr\\cs.g:362:1: pointer_type : type ;
    public csParser.pointer_type_return pointer_type() // throws RecognitionException [1]
    {   
        csParser.pointer_type_return retval = new csParser.pointer_type_return();
        retval.Start = input.LT(1);
        int pointer_type_StartIndex = input.Index();
        object root_0 = null;

        csParser.type_return type320 = default(csParser.type_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 85) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:362:13: ( type )
            // G:\\downloads\\antlr\\cs.g:363:2: type
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_pointer_type2593);
            	type320 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type320.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 85, pointer_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "pointer_type"

    public class block_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "block"
    // G:\\downloads\\antlr\\cs.g:369:1: block : ( ';' | '{' ( statement_list )? '}' );
    public csParser.block_return block() // throws RecognitionException [1]
    {   
        csParser.block_return retval = new csParser.block_return();
        retval.Start = input.LT(1);
        int block_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal321 = null;
        IToken char_literal322 = null;
        IToken char_literal324 = null;
        csParser.statement_list_return statement_list323 = default(csParser.statement_list_return);


        object char_literal321_tree=null;
        object char_literal322_tree=null;
        object char_literal324_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 86) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:369:6: ( ';' | '{' ( statement_list )? '}' )
            int alt99 = 2;
            int LA99_0 = input.LA(1);

            if ( (LA99_0 == SEMI) )
            {
                alt99 = 1;
            }
            else if ( (LA99_0 == 62) )
            {
                alt99 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d99s0 =
                    new NoViableAltException("", 99, 0, input);

                throw nvae_d99s0;
            }
            switch (alt99) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:370:2: ';'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal321=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_block2605); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal321_tree = (object)adaptor.Create(char_literal321);
                    		adaptor.AddChild(root_0, char_literal321_tree);
                    	}

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:371:4: '{' ( statement_list )? '}'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal322=(IToken)Match(input,62,FOLLOW_62_in_block2610); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal322_tree = (object)adaptor.Create(char_literal322);
                    		adaptor.AddChild(root_0, char_literal322_tree);
                    	}
                    	// G:\\downloads\\antlr\\cs.g:371:10: ( statement_list )?
                    	int alt98 = 2;
                    	int LA98_0 = input.LA(1);

                    	if ( ((LA98_0 >= IDENTIFIER && LA98_0 <= NULL) || LA98_0 == MINUS || LA98_0 == USING || LA98_0 == IF || LA98_0 == SEMI || LA98_0 == 62 || LA98_0 == 65 || LA98_0 == 68 || LA98_0 == 73 || (LA98_0 >= 81 && LA98_0 <= 83) || LA98_0 == 85 || LA98_0 == 88 || (LA98_0 >= 93 && LA98_0 <= 98) || LA98_0 == 100 || (LA98_0 >= 102 && LA98_0 <= 106) || LA98_0 == 117 || (LA98_0 >= 132 && LA98_0 <= 133) || (LA98_0 >= 135 && LA98_0 <= 148) || (LA98_0 >= 150 && LA98_0 <= 154) || (LA98_0 >= 157 && LA98_0 <= 168) || LA98_0 == 170 || (LA98_0 >= 176 && LA98_0 <= 178) || LA98_0 == 181 || (LA98_0 >= 183 && LA98_0 <= 191) || (LA98_0 >= 194 && LA98_0 <= 202)) )
                    	{
                    	    alt98 = 1;
                    	}
                    	switch (alt98) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:371:10: statement_list
                    	        {
                    	        	PushFollow(FOLLOW_statement_list_in_block2614);
                    	        	statement_list323 = statement_list();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_list323.Tree);

                    	        }
                    	        break;

                    	}

                    	char_literal324=(IToken)Match(input,63,FOLLOW_63_in_block2619); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal324_tree = (object)adaptor.Create(char_literal324);
                    		adaptor.AddChild(root_0, char_literal324_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 86, block_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "block"

    public class statement_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "statement_list"
    // G:\\downloads\\antlr\\cs.g:372:1: statement_list : ( statement )+ ;
    public csParser.statement_list_return statement_list() // throws RecognitionException [1]
    {   
        csParser.statement_list_return retval = new csParser.statement_list_return();
        retval.Start = input.LT(1);
        int statement_list_StartIndex = input.Index();
        object root_0 = null;

        csParser.statement_return statement325 = default(csParser.statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 87) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:372:15: ( ( statement )+ )
            // G:\\downloads\\antlr\\cs.g:373:2: ( statement )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:373:2: ( statement )+
            	int cnt100 = 0;
            	do 
            	{
            	    int alt100 = 2;
            	    int LA100_0 = input.LA(1);

            	    if ( (LA100_0 == 96) )
            	    {
            	        int LA100_2 = input.LA(2);

            	        if ( (LA100_2 == 88) )
            	        {
            	            alt100 = 1;
            	        }


            	    }
            	    else if ( ((LA100_0 >= IDENTIFIER && LA100_0 <= NULL) || LA100_0 == MINUS || LA100_0 == USING || LA100_0 == IF || LA100_0 == SEMI || LA100_0 == 62 || LA100_0 == 65 || LA100_0 == 68 || LA100_0 == 73 || (LA100_0 >= 81 && LA100_0 <= 83) || LA100_0 == 85 || LA100_0 == 88 || (LA100_0 >= 93 && LA100_0 <= 95) || (LA100_0 >= 97 && LA100_0 <= 98) || LA100_0 == 100 || (LA100_0 >= 102 && LA100_0 <= 106) || LA100_0 == 117 || (LA100_0 >= 132 && LA100_0 <= 133) || (LA100_0 >= 135 && LA100_0 <= 148) || (LA100_0 >= 150 && LA100_0 <= 154) || (LA100_0 >= 157 && LA100_0 <= 168) || LA100_0 == 170 || (LA100_0 >= 176 && LA100_0 <= 178) || LA100_0 == 181 || (LA100_0 >= 183 && LA100_0 <= 191) || (LA100_0 >= 194 && LA100_0 <= 202)) )
            	    {
            	        alt100 = 1;
            	    }


            	    switch (alt100) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:373:2: statement
            			    {
            			    	PushFollow(FOLLOW_statement_in_statement_list2626);
            			    	statement325 = statement();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement325.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt100 >= 1 ) goto loop100;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(100, input);
            		            throw eee;
            	    }
            	    cnt100++;
            	} while (true);

            	loop100:
            		;	// Stops C# compiler whinging that label 'loop100' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 87, statement_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "statement_list"

    public class expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "expression"
    // G:\\downloads\\antlr\\cs.g:378:1: expression : ( ( unary_expression assignment_operator )=> assignment | non_assignment_expression );
    public csParser.expression_return expression() // throws RecognitionException [1]
    {   
        csParser.expression_return retval = new csParser.expression_return();
        retval.Start = input.LT(1);
        int expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.assignment_return assignment326 = default(csParser.assignment_return);

        csParser.non_assignment_expression_return non_assignment_expression327 = default(csParser.non_assignment_expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 88) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:378:11: ( ( unary_expression assignment_operator )=> assignment | non_assignment_expression )
            int alt101 = 2;
            alt101 = dfa101.Predict(input);
            switch (alt101) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:379:2: ( unary_expression assignment_operator )=> assignment
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_assignment_in_expression2651);
                    	assignment326 = assignment();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment326.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:380:4: non_assignment_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_non_assignment_expression_in_expression2657);
                    	non_assignment_expression327 = non_assignment_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_assignment_expression327.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 88, expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expression"

    public class expression_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "expression_list"
    // G:\\downloads\\antlr\\cs.g:382:1: expression_list : expression ( ',' expression )* ;
    public csParser.expression_list_return expression_list() // throws RecognitionException [1]
    {   
        csParser.expression_list_return retval = new csParser.expression_list_return();
        retval.Start = input.LT(1);
        int expression_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal329 = null;
        csParser.expression_return expression328 = default(csParser.expression_return);

        csParser.expression_return expression330 = default(csParser.expression_return);


        object char_literal329_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 89) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:382:16: ( expression ( ',' expression )* )
            // G:\\downloads\\antlr\\cs.g:383:2: expression ( ',' expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_expression_list2666);
            	expression328 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression328.Tree);
            	// G:\\downloads\\antlr\\cs.g:383:14: ( ',' expression )*
            	do 
            	{
            	    int alt102 = 2;
            	    int LA102_0 = input.LA(1);

            	    if ( (LA102_0 == 89) )
            	    {
            	        alt102 = 1;
            	    }


            	    switch (alt102) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:383:15: ',' expression
            			    {
            			    	char_literal329=(IToken)Match(input,89,FOLLOW_89_in_expression_list2670); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal329_tree = (object)adaptor.Create(char_literal329);
            			    		adaptor.AddChild(root_0, char_literal329_tree);
            			    	}
            			    	PushFollow(FOLLOW_expression_in_expression_list2674);
            			    	expression330 = expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression330.Tree);

            			    }
            			    break;

            			default:
            			    goto loop102;
            	    }
            	} while (true);

            	loop102:
            		;	// Stops C# compiler whining that label 'loop102' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 89, expression_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expression_list"

    public class assignment_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "assignment"
    // G:\\downloads\\antlr\\cs.g:384:1: assignment : unary_expression assignment_operator expression ;
    public csParser.assignment_return assignment() // throws RecognitionException [1]
    {   
        csParser.assignment_return retval = new csParser.assignment_return();
        retval.Start = input.LT(1);
        int assignment_StartIndex = input.Index();
        object root_0 = null;

        csParser.unary_expression_return unary_expression331 = default(csParser.unary_expression_return);

        csParser.assignment_operator_return assignment_operator332 = default(csParser.assignment_operator_return);

        csParser.expression_return expression333 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 90) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:384:11: ( unary_expression assignment_operator expression )
            // G:\\downloads\\antlr\\cs.g:385:2: unary_expression assignment_operator expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_unary_expression_in_assignment2684);
            	unary_expression331 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression331.Tree);
            	PushFollow(FOLLOW_assignment_operator_in_assignment2688);
            	assignment_operator332 = assignment_operator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment_operator332.Tree);
            	PushFollow(FOLLOW_expression_in_assignment2692);
            	expression333 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression333.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 90, assignment_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "assignment"

    public class unary_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unary_expression"
    // G:\\downloads\\antlr\\cs.g:386:1: unary_expression : ( ( cast_expression )=> cast_expression | primary_or_array_creation_expression ( '++' )? ( '--' )? | '+' unary_expression | '-' unary_expression | '!' unary_expression | '~' unary_expression | pre_increment_expression | pre_decrement_expression | pointer_indirection_expression | addressof_expression );
    public csParser.unary_expression_return unary_expression() // throws RecognitionException [1]
    {   
        csParser.unary_expression_return retval = new csParser.unary_expression_return();
        retval.Start = input.LT(1);
        int unary_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal336 = null;
        IToken string_literal337 = null;
        IToken char_literal338 = null;
        IToken char_literal340 = null;
        IToken char_literal342 = null;
        IToken char_literal344 = null;
        csParser.cast_expression_return cast_expression334 = default(csParser.cast_expression_return);

        csParser.primary_or_array_creation_expression_return primary_or_array_creation_expression335 = default(csParser.primary_or_array_creation_expression_return);

        csParser.unary_expression_return unary_expression339 = default(csParser.unary_expression_return);

        csParser.unary_expression_return unary_expression341 = default(csParser.unary_expression_return);

        csParser.unary_expression_return unary_expression343 = default(csParser.unary_expression_return);

        csParser.unary_expression_return unary_expression345 = default(csParser.unary_expression_return);

        csParser.pre_increment_expression_return pre_increment_expression346 = default(csParser.pre_increment_expression_return);

        csParser.pre_decrement_expression_return pre_decrement_expression347 = default(csParser.pre_decrement_expression_return);

        csParser.pointer_indirection_expression_return pointer_indirection_expression348 = default(csParser.pointer_indirection_expression_return);

        csParser.addressof_expression_return addressof_expression349 = default(csParser.addressof_expression_return);


        object string_literal336_tree=null;
        object string_literal337_tree=null;
        object char_literal338_tree=null;
        object char_literal340_tree=null;
        object char_literal342_tree=null;
        object char_literal344_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 91) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:386:17: ( ( cast_expression )=> cast_expression | primary_or_array_creation_expression ( '++' )? ( '--' )? | '+' unary_expression | '-' unary_expression | '!' unary_expression | '~' unary_expression | pre_increment_expression | pre_decrement_expression | pointer_indirection_expression | addressof_expression )
            int alt105 = 10;
            alt105 = dfa105.Predict(input);
            switch (alt105) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:388:2: ( cast_expression )=> cast_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_cast_expression_in_unary_expression2709);
                    	cast_expression334 = cast_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, cast_expression334.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:389:4: primary_or_array_creation_expression ( '++' )? ( '--' )?
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_primary_or_array_creation_expression_in_unary_expression2714);
                    	primary_or_array_creation_expression335 = primary_or_array_creation_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_or_array_creation_expression335.Tree);
                    	// G:\\downloads\\antlr\\cs.g:389:43: ( '++' )?
                    	int alt103 = 2;
                    	int LA103_0 = input.LA(1);

                    	if ( (LA103_0 == 102) )
                    	{
                    	    alt103 = 1;
                    	}
                    	switch (alt103) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:389:43: '++'
                    	        {
                    	        	string_literal336=(IToken)Match(input,102,FOLLOW_102_in_unary_expression2718); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{string_literal336_tree = (object)adaptor.Create(string_literal336);
                    	        		adaptor.AddChild(root_0, string_literal336_tree);
                    	        	}

                    	        }
                    	        break;

                    	}

                    	// G:\\downloads\\antlr\\cs.g:389:51: ( '--' )?
                    	int alt104 = 2;
                    	int LA104_0 = input.LA(1);

                    	if ( (LA104_0 == 103) )
                    	{
                    	    alt104 = 1;
                    	}
                    	switch (alt104) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:389:51: '--'
                    	        {
                    	        	string_literal337=(IToken)Match(input,103,FOLLOW_103_in_unary_expression2723); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{string_literal337_tree = (object)adaptor.Create(string_literal337);
                    	        		adaptor.AddChild(root_0, string_literal337_tree);
                    	        	}

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:390:4: '+' unary_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal338=(IToken)Match(input,104,FOLLOW_104_in_unary_expression2729); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal338_tree = (object)adaptor.Create(char_literal338);
                    		adaptor.AddChild(root_0, char_literal338_tree);
                    	}
                    	PushFollow(FOLLOW_unary_expression_in_unary_expression2733);
                    	unary_expression339 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression339.Tree);

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:391:4: '-' unary_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal340=(IToken)Match(input,MINUS,FOLLOW_MINUS_in_unary_expression2739); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal340_tree = (object)adaptor.Create(char_literal340);
                    		adaptor.AddChild(root_0, char_literal340_tree);
                    	}
                    	PushFollow(FOLLOW_unary_expression_in_unary_expression2743);
                    	unary_expression341 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression341.Tree);

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:392:4: '!' unary_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal342=(IToken)Match(input,105,FOLLOW_105_in_unary_expression2749); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal342_tree = (object)adaptor.Create(char_literal342);
                    		adaptor.AddChild(root_0, char_literal342_tree);
                    	}
                    	PushFollow(FOLLOW_unary_expression_in_unary_expression2753);
                    	unary_expression343 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression343.Tree);

                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:393:4: '~' unary_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal344=(IToken)Match(input,106,FOLLOW_106_in_unary_expression2759); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal344_tree = (object)adaptor.Create(char_literal344);
                    		adaptor.AddChild(root_0, char_literal344_tree);
                    	}
                    	PushFollow(FOLLOW_unary_expression_in_unary_expression2763);
                    	unary_expression345 = unary_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression345.Tree);

                    }
                    break;
                case 7 :
                    // G:\\downloads\\antlr\\cs.g:394:4: pre_increment_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_pre_increment_expression_in_unary_expression2769);
                    	pre_increment_expression346 = pre_increment_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pre_increment_expression346.Tree);

                    }
                    break;
                case 8 :
                    // G:\\downloads\\antlr\\cs.g:395:4: pre_decrement_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_pre_decrement_expression_in_unary_expression2775);
                    	pre_decrement_expression347 = pre_decrement_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pre_decrement_expression347.Tree);

                    }
                    break;
                case 9 :
                    // G:\\downloads\\antlr\\cs.g:396:4: pointer_indirection_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_pointer_indirection_expression_in_unary_expression2781);
                    	pointer_indirection_expression348 = pointer_indirection_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pointer_indirection_expression348.Tree);

                    }
                    break;
                case 10 :
                    // G:\\downloads\\antlr\\cs.g:397:4: addressof_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_addressof_expression_in_unary_expression2786);
                    	addressof_expression349 = addressof_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, addressof_expression349.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 91, unary_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unary_expression"

    public class cast_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "cast_expression"
    // G:\\downloads\\antlr\\cs.g:399:1: cast_expression : '(' type ')' unary_expression ;
    public csParser.cast_expression_return cast_expression() // throws RecognitionException [1]
    {   
        csParser.cast_expression_return retval = new csParser.cast_expression_return();
        retval.Start = input.LT(1);
        int cast_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal350 = null;
        IToken char_literal352 = null;
        csParser.type_return type351 = default(csParser.type_return);

        csParser.unary_expression_return unary_expression353 = default(csParser.unary_expression_return);


        object char_literal350_tree=null;
        object char_literal352_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 92) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:399:16: ( '(' type ')' unary_expression )
            // G:\\downloads\\antlr\\cs.g:400:2: '(' type ')' unary_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal350=(IToken)Match(input,88,FOLLOW_88_in_cast_expression2796); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal350_tree = (object)adaptor.Create(char_literal350);
            		adaptor.AddChild(root_0, char_literal350_tree);
            	}
            	PushFollow(FOLLOW_type_in_cast_expression2800);
            	type351 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type351.Tree);
            	char_literal352=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_cast_expression2804); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal352_tree = (object)adaptor.Create(char_literal352);
            		adaptor.AddChild(root_0, char_literal352_tree);
            	}
            	PushFollow(FOLLOW_unary_expression_in_cast_expression2808);
            	unary_expression353 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression353.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 92, cast_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "cast_expression"

    public class assignment_operator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "assignment_operator"
    // G:\\downloads\\antlr\\cs.g:401:1: assignment_operator : ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>' '>=' );
    public csParser.assignment_operator_return assignment_operator() // throws RecognitionException [1]
    {   
        csParser.assignment_operator_return retval = new csParser.assignment_operator_return();
        retval.Start = input.LT(1);
        int assignment_operator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal354 = null;
        IToken string_literal355 = null;
        IToken string_literal356 = null;
        IToken string_literal357 = null;
        IToken string_literal358 = null;
        IToken string_literal359 = null;
        IToken string_literal360 = null;
        IToken string_literal361 = null;
        IToken string_literal362 = null;
        IToken string_literal363 = null;
        IToken char_literal364 = null;
        IToken string_literal365 = null;

        object char_literal354_tree=null;
        object string_literal355_tree=null;
        object string_literal356_tree=null;
        object string_literal357_tree=null;
        object string_literal358_tree=null;
        object string_literal359_tree=null;
        object string_literal360_tree=null;
        object string_literal361_tree=null;
        object string_literal362_tree=null;
        object string_literal363_tree=null;
        object char_literal364_tree=null;
        object string_literal365_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 93) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:401:20: ( '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>' '>=' )
            int alt106 = 11;
            switch ( input.LA(1) ) 
            {
            case 66:
            	{
                alt106 = 1;
                }
                break;
            case 107:
            	{
                alt106 = 2;
                }
                break;
            case 108:
            	{
                alt106 = 3;
                }
                break;
            case 109:
            	{
                alt106 = 4;
                }
                break;
            case 110:
            	{
                alt106 = 5;
                }
                break;
            case 111:
            	{
                alt106 = 6;
                }
                break;
            case 112:
            	{
                alt106 = 7;
                }
                break;
            case 113:
            	{
                alt106 = 8;
                }
                break;
            case 114:
            	{
                alt106 = 9;
                }
                break;
            case 115:
            	{
                alt106 = 10;
                }
                break;
            case GT:
            	{
                alt106 = 11;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d106s0 =
            	        new NoViableAltException("", 106, 0, input);

            	    throw nvae_d106s0;
            }

            switch (alt106) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:402:2: '='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal354=(IToken)Match(input,66,FOLLOW_66_in_assignment_operator2816); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal354_tree = (object)adaptor.Create(char_literal354);
                    		adaptor.AddChild(root_0, char_literal354_tree);
                    	}

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:402:8: '+='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal355=(IToken)Match(input,107,FOLLOW_107_in_assignment_operator2820); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal355_tree = (object)adaptor.Create(string_literal355);
                    		adaptor.AddChild(root_0, string_literal355_tree);
                    	}

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:402:15: '-='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal356=(IToken)Match(input,108,FOLLOW_108_in_assignment_operator2824); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal356_tree = (object)adaptor.Create(string_literal356);
                    		adaptor.AddChild(root_0, string_literal356_tree);
                    	}

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:402:22: '*='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal357=(IToken)Match(input,109,FOLLOW_109_in_assignment_operator2828); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal357_tree = (object)adaptor.Create(string_literal357);
                    		adaptor.AddChild(root_0, string_literal357_tree);
                    	}

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:402:29: '/='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal358=(IToken)Match(input,110,FOLLOW_110_in_assignment_operator2832); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal358_tree = (object)adaptor.Create(string_literal358);
                    		adaptor.AddChild(root_0, string_literal358_tree);
                    	}

                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:402:36: '%='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal359=(IToken)Match(input,111,FOLLOW_111_in_assignment_operator2836); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal359_tree = (object)adaptor.Create(string_literal359);
                    		adaptor.AddChild(root_0, string_literal359_tree);
                    	}

                    }
                    break;
                case 7 :
                    // G:\\downloads\\antlr\\cs.g:402:43: '&='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal360=(IToken)Match(input,112,FOLLOW_112_in_assignment_operator2840); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal360_tree = (object)adaptor.Create(string_literal360);
                    		adaptor.AddChild(root_0, string_literal360_tree);
                    	}

                    }
                    break;
                case 8 :
                    // G:\\downloads\\antlr\\cs.g:402:50: '|='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal361=(IToken)Match(input,113,FOLLOW_113_in_assignment_operator2844); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal361_tree = (object)adaptor.Create(string_literal361);
                    		adaptor.AddChild(root_0, string_literal361_tree);
                    	}

                    }
                    break;
                case 9 :
                    // G:\\downloads\\antlr\\cs.g:402:57: '^='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal362=(IToken)Match(input,114,FOLLOW_114_in_assignment_operator2848); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal362_tree = (object)adaptor.Create(string_literal362);
                    		adaptor.AddChild(root_0, string_literal362_tree);
                    	}

                    }
                    break;
                case 10 :
                    // G:\\downloads\\antlr\\cs.g:402:64: '<<='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal363=(IToken)Match(input,115,FOLLOW_115_in_assignment_operator2852); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal363_tree = (object)adaptor.Create(string_literal363);
                    		adaptor.AddChild(root_0, string_literal363_tree);
                    	}

                    }
                    break;
                case 11 :
                    // G:\\downloads\\antlr\\cs.g:402:72: '>' '>='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal364=(IToken)Match(input,GT,FOLLOW_GT_in_assignment_operator2856); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal364_tree = (object)adaptor.Create(char_literal364);
                    		adaptor.AddChild(root_0, char_literal364_tree);
                    	}
                    	string_literal365=(IToken)Match(input,116,FOLLOW_116_in_assignment_operator2858); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal365_tree = (object)adaptor.Create(string_literal365);
                    		adaptor.AddChild(root_0, string_literal365_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 93, assignment_operator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "assignment_operator"

    public class pre_increment_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "pre_increment_expression"
    // G:\\downloads\\antlr\\cs.g:403:1: pre_increment_expression : '++' unary_expression ;
    public csParser.pre_increment_expression_return pre_increment_expression() // throws RecognitionException [1]
    {   
        csParser.pre_increment_expression_return retval = new csParser.pre_increment_expression_return();
        retval.Start = input.LT(1);
        int pre_increment_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal366 = null;
        csParser.unary_expression_return unary_expression367 = default(csParser.unary_expression_return);


        object string_literal366_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 94) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:403:25: ( '++' unary_expression )
            // G:\\downloads\\antlr\\cs.g:404:2: '++' unary_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal366=(IToken)Match(input,102,FOLLOW_102_in_pre_increment_expression2867); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal366_tree = (object)adaptor.Create(string_literal366);
            		adaptor.AddChild(root_0, string_literal366_tree);
            	}
            	PushFollow(FOLLOW_unary_expression_in_pre_increment_expression2871);
            	unary_expression367 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression367.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 94, pre_increment_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "pre_increment_expression"

    public class pre_decrement_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "pre_decrement_expression"
    // G:\\downloads\\antlr\\cs.g:405:1: pre_decrement_expression : '--' unary_expression ;
    public csParser.pre_decrement_expression_return pre_decrement_expression() // throws RecognitionException [1]
    {   
        csParser.pre_decrement_expression_return retval = new csParser.pre_decrement_expression_return();
        retval.Start = input.LT(1);
        int pre_decrement_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal368 = null;
        csParser.unary_expression_return unary_expression369 = default(csParser.unary_expression_return);


        object string_literal368_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 95) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:405:25: ( '--' unary_expression )
            // G:\\downloads\\antlr\\cs.g:406:2: '--' unary_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal368=(IToken)Match(input,103,FOLLOW_103_in_pre_decrement_expression2880); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal368_tree = (object)adaptor.Create(string_literal368);
            		adaptor.AddChild(root_0, string_literal368_tree);
            	}
            	PushFollow(FOLLOW_unary_expression_in_pre_decrement_expression2884);
            	unary_expression369 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression369.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 95, pre_decrement_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "pre_decrement_expression"

    public class pointer_indirection_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "pointer_indirection_expression"
    // G:\\downloads\\antlr\\cs.g:407:1: pointer_indirection_expression : '*' unary_expression ;
    public csParser.pointer_indirection_expression_return pointer_indirection_expression() // throws RecognitionException [1]
    {   
        csParser.pointer_indirection_expression_return retval = new csParser.pointer_indirection_expression_return();
        retval.Start = input.LT(1);
        int pointer_indirection_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal370 = null;
        csParser.unary_expression_return unary_expression371 = default(csParser.unary_expression_return);


        object char_literal370_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 96) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:407:31: ( '*' unary_expression )
            // G:\\downloads\\antlr\\cs.g:408:2: '*' unary_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal370=(IToken)Match(input,100,FOLLOW_100_in_pointer_indirection_expression2892); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal370_tree = (object)adaptor.Create(char_literal370);
            		adaptor.AddChild(root_0, char_literal370_tree);
            	}
            	PushFollow(FOLLOW_unary_expression_in_pointer_indirection_expression2896);
            	unary_expression371 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression371.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 96, pointer_indirection_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "pointer_indirection_expression"

    public class addressof_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "addressof_expression"
    // G:\\downloads\\antlr\\cs.g:409:1: addressof_expression : '&' unary_expression ;
    public csParser.addressof_expression_return addressof_expression() // throws RecognitionException [1]
    {   
        csParser.addressof_expression_return retval = new csParser.addressof_expression_return();
        retval.Start = input.LT(1);
        int addressof_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal372 = null;
        csParser.unary_expression_return unary_expression373 = default(csParser.unary_expression_return);


        object char_literal372_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 97) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:409:21: ( '&' unary_expression )
            // G:\\downloads\\antlr\\cs.g:410:2: '&' unary_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal372=(IToken)Match(input,117,FOLLOW_117_in_addressof_expression2904); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal372_tree = (object)adaptor.Create(char_literal372);
            		adaptor.AddChild(root_0, char_literal372_tree);
            	}
            	PushFollow(FOLLOW_unary_expression_in_addressof_expression2908);
            	unary_expression373 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression373.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 97, addressof_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "addressof_expression"

    public class non_assignment_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "non_assignment_expression"
    // G:\\downloads\\antlr\\cs.g:412:1: non_assignment_expression : ( ( anonymous_function_signature '=>' )=> lambda_expression | ( query_expression )=> query_expression | conditional_expression );
    public csParser.non_assignment_expression_return non_assignment_expression() // throws RecognitionException [1]
    {   
        csParser.non_assignment_expression_return retval = new csParser.non_assignment_expression_return();
        retval.Start = input.LT(1);
        int non_assignment_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.lambda_expression_return lambda_expression374 = default(csParser.lambda_expression_return);

        csParser.query_expression_return query_expression375 = default(csParser.query_expression_return);

        csParser.conditional_expression_return conditional_expression376 = default(csParser.conditional_expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 98) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:412:26: ( ( anonymous_function_signature '=>' )=> lambda_expression | ( query_expression )=> query_expression | conditional_expression )
            int alt107 = 3;
            alt107 = dfa107.Predict(input);
            switch (alt107) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:414:2: ( anonymous_function_signature '=>' )=> lambda_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_lambda_expression_in_non_assignment_expression2929);
                    	lambda_expression374 = lambda_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, lambda_expression374.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:415:4: ( query_expression )=> query_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_query_expression_in_non_assignment_expression2940);
                    	query_expression375 = query_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_expression375.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:416:4: conditional_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_conditional_expression_in_non_assignment_expression2946);
                    	conditional_expression376 = conditional_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_expression376.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 98, non_assignment_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "non_assignment_expression"

    public class multiplicative_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "multiplicative_expression"
    // G:\\downloads\\antlr\\cs.g:423:1: multiplicative_expression : unary_expression ( ( '*' | '/' | '%' ) unary_expression )* ;
    public csParser.multiplicative_expression_return multiplicative_expression() // throws RecognitionException [1]
    {   
        csParser.multiplicative_expression_return retval = new csParser.multiplicative_expression_return();
        retval.Start = input.LT(1);
        int multiplicative_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken set378 = null;
        csParser.unary_expression_return unary_expression377 = default(csParser.unary_expression_return);

        csParser.unary_expression_return unary_expression379 = default(csParser.unary_expression_return);


        object set378_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 99) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:423:26: ( unary_expression ( ( '*' | '/' | '%' ) unary_expression )* )
            // G:\\downloads\\antlr\\cs.g:424:2: unary_expression ( ( '*' | '/' | '%' ) unary_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_unary_expression_in_multiplicative_expression2960);
            	unary_expression377 = unary_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression377.Tree);
            	// G:\\downloads\\antlr\\cs.g:424:19: ( ( '*' | '/' | '%' ) unary_expression )*
            	do 
            	{
            	    int alt108 = 2;
            	    int LA108_0 = input.LA(1);

            	    if ( (LA108_0 == 100 || (LA108_0 >= 118 && LA108_0 <= 119)) )
            	    {
            	        alt108 = 1;
            	    }


            	    switch (alt108) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:424:22: ( '*' | '/' | '%' ) unary_expression
            			    {
            			    	set378 = (IToken)input.LT(1);
            			    	if ( input.LA(1) == 100 || (input.LA(1) >= 118 && input.LA(1) <= 119) ) 
            			    	{
            			    	    input.Consume();
            			    	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set378));
            			    	    state.errorRecovery = false;state.failed = false;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    throw mse;
            			    	}

            			    	PushFollow(FOLLOW_unary_expression_in_multiplicative_expression2975);
            			    	unary_expression379 = unary_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression379.Tree);

            			    }
            			    break;

            			default:
            			    goto loop108;
            	    }
            	} while (true);

            	loop108:
            		;	// Stops C# compiler whining that label 'loop108' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 99, multiplicative_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "multiplicative_expression"

    public class additive_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "additive_expression"
    // G:\\downloads\\antlr\\cs.g:425:1: additive_expression : multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* ;
    public csParser.additive_expression_return additive_expression() // throws RecognitionException [1]
    {   
        csParser.additive_expression_return retval = new csParser.additive_expression_return();
        retval.Start = input.LT(1);
        int additive_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken set381 = null;
        csParser.multiplicative_expression_return multiplicative_expression380 = default(csParser.multiplicative_expression_return);

        csParser.multiplicative_expression_return multiplicative_expression382 = default(csParser.multiplicative_expression_return);


        object set381_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 100) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:425:20: ( multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* )
            // G:\\downloads\\antlr\\cs.g:426:2: multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_multiplicative_expression_in_additive_expression2985);
            	multiplicative_expression380 = multiplicative_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicative_expression380.Tree);
            	// G:\\downloads\\antlr\\cs.g:426:28: ( ( '+' | '-' ) multiplicative_expression )*
            	do 
            	{
            	    int alt109 = 2;
            	    int LA109_0 = input.LA(1);

            	    if ( (LA109_0 == MINUS || LA109_0 == 104) )
            	    {
            	        alt109 = 1;
            	    }


            	    switch (alt109) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:426:29: ( '+' | '-' ) multiplicative_expression
            			    {
            			    	set381 = (IToken)input.LT(1);
            			    	if ( input.LA(1) == MINUS || input.LA(1) == 104 ) 
            			    	{
            			    	    input.Consume();
            			    	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set381));
            			    	    state.errorRecovery = false;state.failed = false;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    throw mse;
            			    	}

            			    	PushFollow(FOLLOW_multiplicative_expression_in_additive_expression2996);
            			    	multiplicative_expression382 = multiplicative_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, multiplicative_expression382.Tree);

            			    }
            			    break;

            			default:
            			    goto loop109;
            	    }
            	} while (true);

            	loop109:
            		;	// Stops C# compiler whining that label 'loop109' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 100, additive_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "additive_expression"

    public class shift_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "shift_expression"
    // G:\\downloads\\antlr\\cs.g:428:1: shift_expression : additive_expression ( ( '<<' | '>' '>' ) additive_expression )* ;
    public csParser.shift_expression_return shift_expression() // throws RecognitionException [1]
    {   
        csParser.shift_expression_return retval = new csParser.shift_expression_return();
        retval.Start = input.LT(1);
        int shift_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal384 = null;
        IToken char_literal385 = null;
        IToken char_literal386 = null;
        csParser.additive_expression_return additive_expression383 = default(csParser.additive_expression_return);

        csParser.additive_expression_return additive_expression387 = default(csParser.additive_expression_return);


        object string_literal384_tree=null;
        object char_literal385_tree=null;
        object char_literal386_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 101) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:428:17: ( additive_expression ( ( '<<' | '>' '>' ) additive_expression )* )
            // G:\\downloads\\antlr\\cs.g:429:2: additive_expression ( ( '<<' | '>' '>' ) additive_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_additive_expression_in_shift_expression3007);
            	additive_expression383 = additive_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, additive_expression383.Tree);
            	// G:\\downloads\\antlr\\cs.g:429:22: ( ( '<<' | '>' '>' ) additive_expression )*
            	do 
            	{
            	    int alt111 = 2;
            	    int LA111_0 = input.LA(1);

            	    if ( (LA111_0 == GT) )
            	    {
            	        int LA111_1 = input.LA(2);

            	        if ( (LA111_1 == GT) )
            	        {
            	            alt111 = 1;
            	        }


            	    }
            	    else if ( (LA111_0 == 120) )
            	    {
            	        alt111 = 1;
            	    }


            	    switch (alt111) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:429:23: ( '<<' | '>' '>' ) additive_expression
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:429:23: ( '<<' | '>' '>' )
            			    	int alt110 = 2;
            			    	int LA110_0 = input.LA(1);

            			    	if ( (LA110_0 == 120) )
            			    	{
            			    	    alt110 = 1;
            			    	}
            			    	else if ( (LA110_0 == GT) )
            			    	{
            			    	    alt110 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d110s0 =
            			    	        new NoViableAltException("", 110, 0, input);

            			    	    throw nvae_d110s0;
            			    	}
            			    	switch (alt110) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:429:24: '<<'
            			    	        {
            			    	        	string_literal384=(IToken)Match(input,120,FOLLOW_120_in_shift_expression3011); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal384_tree = (object)adaptor.Create(string_literal384);
            			    	        		adaptor.AddChild(root_0, string_literal384_tree);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // G:\\downloads\\antlr\\cs.g:429:29: '>' '>'
            			    	        {
            			    	        	char_literal385=(IToken)Match(input,GT,FOLLOW_GT_in_shift_expression3013); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{char_literal385_tree = (object)adaptor.Create(char_literal385);
            			    	        		adaptor.AddChild(root_0, char_literal385_tree);
            			    	        	}
            			    	        	char_literal386=(IToken)Match(input,GT,FOLLOW_GT_in_shift_expression3015); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{char_literal386_tree = (object)adaptor.Create(char_literal386);
            			    	        		adaptor.AddChild(root_0, char_literal386_tree);
            			    	        	}

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_additive_expression_in_shift_expression3018);
            			    	additive_expression387 = additive_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, additive_expression387.Tree);

            			    }
            			    break;

            			default:
            			    goto loop111;
            	    }
            	} while (true);

            	loop111:
            		;	// Stops C# compiler whining that label 'loop111' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 101, shift_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "shift_expression"

    public class relational_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "relational_expression"
    // G:\\downloads\\antlr\\cs.g:430:1: relational_expression : shift_expression ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )* ;
    public csParser.relational_expression_return relational_expression() // throws RecognitionException [1]
    {   
        csParser.relational_expression_return retval = new csParser.relational_expression_return();
        retval.Start = input.LT(1);
        int relational_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken set389 = null;
        IToken set391 = null;
        csParser.shift_expression_return shift_expression388 = default(csParser.shift_expression_return);

        csParser.shift_expression_return shift_expression390 = default(csParser.shift_expression_return);

        csParser.non_nullable_type_return non_nullable_type392 = default(csParser.non_nullable_type_return);


        object set389_tree=null;
        object set391_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 102) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:430:22: ( shift_expression ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )* )
            // G:\\downloads\\antlr\\cs.g:431:2: shift_expression ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_shift_expression_in_relational_expression3028);
            	shift_expression388 = shift_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, shift_expression388.Tree);
            	// G:\\downloads\\antlr\\cs.g:432:3: ( ( ( '<' | '>' | '>=' | '<=' ) shift_expression ) | ( ( 'is' | 'as' ) non_nullable_type ) )*
            	do 
            	{
            	    int alt112 = 3;
            	    int LA112_0 = input.LA(1);

            	    if ( (LA112_0 == GT || LA112_0 == 99 || LA112_0 == 116 || LA112_0 == 121) )
            	    {
            	        alt112 = 1;
            	    }
            	    else if ( ((LA112_0 >= 122 && LA112_0 <= 123)) )
            	    {
            	        alt112 = 2;
            	    }


            	    switch (alt112) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:432:5: ( ( '<' | '>' | '>=' | '<=' ) shift_expression )
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:432:5: ( ( '<' | '>' | '>=' | '<=' ) shift_expression )
            			    	// G:\\downloads\\antlr\\cs.g:432:6: ( '<' | '>' | '>=' | '<=' ) shift_expression
            			    	{
            			    		set389 = (IToken)input.LT(1);
            			    		if ( input.LA(1) == GT || input.LA(1) == 99 || input.LA(1) == 116 || input.LA(1) == 121 ) 
            			    		{
            			    		    input.Consume();
            			    		    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set389));
            			    		    state.errorRecovery = false;state.failed = false;
            			    		}
            			    		else 
            			    		{
            			    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    		    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    		    throw mse;
            			    		}

            			    		PushFollow(FOLLOW_shift_expression_in_relational_expression3045);
            			    		shift_expression390 = shift_expression();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, shift_expression390.Tree);

            			    	}


            			    }
            			    break;
            			case 2 :
            			    // G:\\downloads\\antlr\\cs.g:433:6: ( ( 'is' | 'as' ) non_nullable_type )
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:433:6: ( ( 'is' | 'as' ) non_nullable_type )
            			    	// G:\\downloads\\antlr\\cs.g:433:7: ( 'is' | 'as' ) non_nullable_type
            			    	{
            			    		set391 = (IToken)input.LT(1);
            			    		if ( (input.LA(1) >= 122 && input.LA(1) <= 123) ) 
            			    		{
            			    		    input.Consume();
            			    		    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set391));
            			    		    state.errorRecovery = false;state.failed = false;
            			    		}
            			    		else 
            			    		{
            			    		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    		    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    		    throw mse;
            			    		}

            			    		PushFollow(FOLLOW_non_nullable_type_in_relational_expression3062);
            			    		non_nullable_type392 = non_nullable_type();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_nullable_type392.Tree);

            			    	}


            			    }
            			    break;

            			default:
            			    goto loop112;
            	    }
            	} while (true);

            	loop112:
            		;	// Stops C# compiler whining that label 'loop112' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 102, relational_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "relational_expression"

    public class equality_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "equality_expression"
    // G:\\downloads\\antlr\\cs.g:435:1: equality_expression : relational_expression ( ( '==' | '!=' ) relational_expression )* ;
    public csParser.equality_expression_return equality_expression() // throws RecognitionException [1]
    {   
        csParser.equality_expression_return retval = new csParser.equality_expression_return();
        retval.Start = input.LT(1);
        int equality_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken set394 = null;
        csParser.relational_expression_return relational_expression393 = default(csParser.relational_expression_return);

        csParser.relational_expression_return relational_expression395 = default(csParser.relational_expression_return);


        object set394_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 103) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:435:20: ( relational_expression ( ( '==' | '!=' ) relational_expression )* )
            // G:\\downloads\\antlr\\cs.g:436:2: relational_expression ( ( '==' | '!=' ) relational_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_relational_expression_in_equality_expression3076);
            	relational_expression393 = relational_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relational_expression393.Tree);
            	// G:\\downloads\\antlr\\cs.g:437:5: ( ( '==' | '!=' ) relational_expression )*
            	do 
            	{
            	    int alt113 = 2;
            	    int LA113_0 = input.LA(1);

            	    if ( ((LA113_0 >= 124 && LA113_0 <= 125)) )
            	    {
            	        alt113 = 1;
            	    }


            	    switch (alt113) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:437:6: ( '==' | '!=' ) relational_expression
            			    {
            			    	set394 = (IToken)input.LT(1);
            			    	if ( (input.LA(1) >= 124 && input.LA(1) <= 125) ) 
            			    	{
            			    	    input.Consume();
            			    	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set394));
            			    	    state.errorRecovery = false;state.failed = false;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    MismatchedSetException mse = new MismatchedSetException(null,input);
            			    	    throw mse;
            			    	}

            			    	PushFollow(FOLLOW_relational_expression_in_equality_expression3091);
            			    	relational_expression395 = relational_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relational_expression395.Tree);

            			    }
            			    break;

            			default:
            			    goto loop113;
            	    }
            	} while (true);

            	loop113:
            		;	// Stops C# compiler whining that label 'loop113' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 103, equality_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "equality_expression"

    public class and_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "and_expression"
    // G:\\downloads\\antlr\\cs.g:438:1: and_expression : equality_expression ( '&' equality_expression )* ;
    public csParser.and_expression_return and_expression() // throws RecognitionException [1]
    {   
        csParser.and_expression_return retval = new csParser.and_expression_return();
        retval.Start = input.LT(1);
        int and_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal397 = null;
        csParser.equality_expression_return equality_expression396 = default(csParser.equality_expression_return);

        csParser.equality_expression_return equality_expression398 = default(csParser.equality_expression_return);


        object char_literal397_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 104) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:438:15: ( equality_expression ( '&' equality_expression )* )
            // G:\\downloads\\antlr\\cs.g:439:2: equality_expression ( '&' equality_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_equality_expression_in_and_expression3101);
            	equality_expression396 = equality_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equality_expression396.Tree);
            	// G:\\downloads\\antlr\\cs.g:439:22: ( '&' equality_expression )*
            	do 
            	{
            	    int alt114 = 2;
            	    int LA114_0 = input.LA(1);

            	    if ( (LA114_0 == 117) )
            	    {
            	        alt114 = 1;
            	    }


            	    switch (alt114) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:439:23: '&' equality_expression
            			    {
            			    	char_literal397=(IToken)Match(input,117,FOLLOW_117_in_and_expression3104); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal397_tree = (object)adaptor.Create(char_literal397);
            			    		adaptor.AddChild(root_0, char_literal397_tree);
            			    	}
            			    	PushFollow(FOLLOW_equality_expression_in_and_expression3108);
            			    	equality_expression398 = equality_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equality_expression398.Tree);

            			    }
            			    break;

            			default:
            			    goto loop114;
            	    }
            	} while (true);

            	loop114:
            		;	// Stops C# compiler whining that label 'loop114' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 104, and_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "and_expression"

    public class exclusive_or_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "exclusive_or_expression"
    // G:\\downloads\\antlr\\cs.g:440:1: exclusive_or_expression : and_expression ( '^' and_expression )* ;
    public csParser.exclusive_or_expression_return exclusive_or_expression() // throws RecognitionException [1]
    {   
        csParser.exclusive_or_expression_return retval = new csParser.exclusive_or_expression_return();
        retval.Start = input.LT(1);
        int exclusive_or_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal400 = null;
        csParser.and_expression_return and_expression399 = default(csParser.and_expression_return);

        csParser.and_expression_return and_expression401 = default(csParser.and_expression_return);


        object char_literal400_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 105) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:440:24: ( and_expression ( '^' and_expression )* )
            // G:\\downloads\\antlr\\cs.g:441:2: and_expression ( '^' and_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_and_expression_in_exclusive_or_expression3118);
            	and_expression399 = and_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, and_expression399.Tree);
            	// G:\\downloads\\antlr\\cs.g:441:17: ( '^' and_expression )*
            	do 
            	{
            	    int alt115 = 2;
            	    int LA115_0 = input.LA(1);

            	    if ( (LA115_0 == 126) )
            	    {
            	        alt115 = 1;
            	    }


            	    switch (alt115) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:441:18: '^' and_expression
            			    {
            			    	char_literal400=(IToken)Match(input,126,FOLLOW_126_in_exclusive_or_expression3121); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal400_tree = (object)adaptor.Create(char_literal400);
            			    		adaptor.AddChild(root_0, char_literal400_tree);
            			    	}
            			    	PushFollow(FOLLOW_and_expression_in_exclusive_or_expression3125);
            			    	and_expression401 = and_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, and_expression401.Tree);

            			    }
            			    break;

            			default:
            			    goto loop115;
            	    }
            	} while (true);

            	loop115:
            		;	// Stops C# compiler whining that label 'loop115' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 105, exclusive_or_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "exclusive_or_expression"

    public class inclusive_or_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "inclusive_or_expression"
    // G:\\downloads\\antlr\\cs.g:442:1: inclusive_or_expression : exclusive_or_expression ( '|' exclusive_or_expression )* ;
    public csParser.inclusive_or_expression_return inclusive_or_expression() // throws RecognitionException [1]
    {   
        csParser.inclusive_or_expression_return retval = new csParser.inclusive_or_expression_return();
        retval.Start = input.LT(1);
        int inclusive_or_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal403 = null;
        csParser.exclusive_or_expression_return exclusive_or_expression402 = default(csParser.exclusive_or_expression_return);

        csParser.exclusive_or_expression_return exclusive_or_expression404 = default(csParser.exclusive_or_expression_return);


        object char_literal403_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 106) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:442:24: ( exclusive_or_expression ( '|' exclusive_or_expression )* )
            // G:\\downloads\\antlr\\cs.g:443:2: exclusive_or_expression ( '|' exclusive_or_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_exclusive_or_expression_in_inclusive_or_expression3135);
            	exclusive_or_expression402 = exclusive_or_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exclusive_or_expression402.Tree);
            	// G:\\downloads\\antlr\\cs.g:443:28: ( '|' exclusive_or_expression )*
            	do 
            	{
            	    int alt116 = 2;
            	    int LA116_0 = input.LA(1);

            	    if ( (LA116_0 == 127) )
            	    {
            	        alt116 = 1;
            	    }


            	    switch (alt116) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:443:29: '|' exclusive_or_expression
            			    {
            			    	char_literal403=(IToken)Match(input,127,FOLLOW_127_in_inclusive_or_expression3140); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal403_tree = (object)adaptor.Create(char_literal403);
            			    		adaptor.AddChild(root_0, char_literal403_tree);
            			    	}
            			    	PushFollow(FOLLOW_exclusive_or_expression_in_inclusive_or_expression3144);
            			    	exclusive_or_expression404 = exclusive_or_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, exclusive_or_expression404.Tree);

            			    }
            			    break;

            			default:
            			    goto loop116;
            	    }
            	} while (true);

            	loop116:
            		;	// Stops C# compiler whining that label 'loop116' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 106, inclusive_or_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "inclusive_or_expression"

    public class conditional_and_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "conditional_and_expression"
    // G:\\downloads\\antlr\\cs.g:444:1: conditional_and_expression : inclusive_or_expression ( '&&' inclusive_or_expression )* ;
    public csParser.conditional_and_expression_return conditional_and_expression() // throws RecognitionException [1]
    {   
        csParser.conditional_and_expression_return retval = new csParser.conditional_and_expression_return();
        retval.Start = input.LT(1);
        int conditional_and_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal406 = null;
        csParser.inclusive_or_expression_return inclusive_or_expression405 = default(csParser.inclusive_or_expression_return);

        csParser.inclusive_or_expression_return inclusive_or_expression407 = default(csParser.inclusive_or_expression_return);


        object string_literal406_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 107) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:444:27: ( inclusive_or_expression ( '&&' inclusive_or_expression )* )
            // G:\\downloads\\antlr\\cs.g:445:2: inclusive_or_expression ( '&&' inclusive_or_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_inclusive_or_expression_in_conditional_and_expression3154);
            	inclusive_or_expression405 = inclusive_or_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, inclusive_or_expression405.Tree);
            	// G:\\downloads\\antlr\\cs.g:445:28: ( '&&' inclusive_or_expression )*
            	do 
            	{
            	    int alt117 = 2;
            	    int LA117_0 = input.LA(1);

            	    if ( (LA117_0 == 128) )
            	    {
            	        alt117 = 1;
            	    }


            	    switch (alt117) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:445:29: '&&' inclusive_or_expression
            			    {
            			    	string_literal406=(IToken)Match(input,128,FOLLOW_128_in_conditional_and_expression3159); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{string_literal406_tree = (object)adaptor.Create(string_literal406);
            			    		adaptor.AddChild(root_0, string_literal406_tree);
            			    	}
            			    	PushFollow(FOLLOW_inclusive_or_expression_in_conditional_and_expression3163);
            			    	inclusive_or_expression407 = inclusive_or_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, inclusive_or_expression407.Tree);

            			    }
            			    break;

            			default:
            			    goto loop117;
            	    }
            	} while (true);

            	loop117:
            		;	// Stops C# compiler whining that label 'loop117' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 107, conditional_and_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "conditional_and_expression"

    public class conditional_or_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "conditional_or_expression"
    // G:\\downloads\\antlr\\cs.g:446:1: conditional_or_expression : conditional_and_expression ( '||' conditional_and_expression )* ;
    public csParser.conditional_or_expression_return conditional_or_expression() // throws RecognitionException [1]
    {   
        csParser.conditional_or_expression_return retval = new csParser.conditional_or_expression_return();
        retval.Start = input.LT(1);
        int conditional_or_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal409 = null;
        csParser.conditional_and_expression_return conditional_and_expression408 = default(csParser.conditional_and_expression_return);

        csParser.conditional_and_expression_return conditional_and_expression410 = default(csParser.conditional_and_expression_return);


        object string_literal409_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 108) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:446:26: ( conditional_and_expression ( '||' conditional_and_expression )* )
            // G:\\downloads\\antlr\\cs.g:447:2: conditional_and_expression ( '||' conditional_and_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_conditional_and_expression_in_conditional_or_expression3173);
            	conditional_and_expression408 = conditional_and_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_and_expression408.Tree);
            	// G:\\downloads\\antlr\\cs.g:447:30: ( '||' conditional_and_expression )*
            	do 
            	{
            	    int alt118 = 2;
            	    int LA118_0 = input.LA(1);

            	    if ( (LA118_0 == 129) )
            	    {
            	        alt118 = 1;
            	    }


            	    switch (alt118) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:447:31: '||' conditional_and_expression
            			    {
            			    	string_literal409=(IToken)Match(input,129,FOLLOW_129_in_conditional_or_expression3177); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{string_literal409_tree = (object)adaptor.Create(string_literal409);
            			    		adaptor.AddChild(root_0, string_literal409_tree);
            			    	}
            			    	PushFollow(FOLLOW_conditional_and_expression_in_conditional_or_expression3181);
            			    	conditional_and_expression410 = conditional_and_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_and_expression410.Tree);

            			    }
            			    break;

            			default:
            			    goto loop118;
            	    }
            	} while (true);

            	loop118:
            		;	// Stops C# compiler whining that label 'loop118' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 108, conditional_or_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "conditional_or_expression"

    public class null_coalescing_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "null_coalescing_expression"
    // G:\\downloads\\antlr\\cs.g:449:1: null_coalescing_expression : conditional_or_expression ( '??' conditional_or_expression )* ;
    public csParser.null_coalescing_expression_return null_coalescing_expression() // throws RecognitionException [1]
    {   
        csParser.null_coalescing_expression_return retval = new csParser.null_coalescing_expression_return();
        retval.Start = input.LT(1);
        int null_coalescing_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal412 = null;
        csParser.conditional_or_expression_return conditional_or_expression411 = default(csParser.conditional_or_expression_return);

        csParser.conditional_or_expression_return conditional_or_expression413 = default(csParser.conditional_or_expression_return);


        object string_literal412_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 109) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:449:27: ( conditional_or_expression ( '??' conditional_or_expression )* )
            // G:\\downloads\\antlr\\cs.g:450:2: conditional_or_expression ( '??' conditional_or_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_conditional_or_expression_in_null_coalescing_expression3192);
            	conditional_or_expression411 = conditional_or_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_or_expression411.Tree);
            	// G:\\downloads\\antlr\\cs.g:450:30: ( '??' conditional_or_expression )*
            	do 
            	{
            	    int alt119 = 2;
            	    int LA119_0 = input.LA(1);

            	    if ( (LA119_0 == 130) )
            	    {
            	        alt119 = 1;
            	    }


            	    switch (alt119) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:450:31: '??' conditional_or_expression
            			    {
            			    	string_literal412=(IToken)Match(input,130,FOLLOW_130_in_null_coalescing_expression3197); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{string_literal412_tree = (object)adaptor.Create(string_literal412);
            			    		adaptor.AddChild(root_0, string_literal412_tree);
            			    	}
            			    	PushFollow(FOLLOW_conditional_or_expression_in_null_coalescing_expression3201);
            			    	conditional_or_expression413 = conditional_or_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conditional_or_expression413.Tree);

            			    }
            			    break;

            			default:
            			    goto loop119;
            	    }
            	} while (true);

            	loop119:
            		;	// Stops C# compiler whining that label 'loop119' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 109, null_coalescing_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "null_coalescing_expression"

    public class conditional_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "conditional_expression"
    // G:\\downloads\\antlr\\cs.g:451:1: conditional_expression : null_coalescing_expression ( '?' expression ':' expression )? ;
    public csParser.conditional_expression_return conditional_expression() // throws RecognitionException [1]
    {   
        csParser.conditional_expression_return retval = new csParser.conditional_expression_return();
        retval.Start = input.LT(1);
        int conditional_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal415 = null;
        IToken char_literal417 = null;
        csParser.null_coalescing_expression_return null_coalescing_expression414 = default(csParser.null_coalescing_expression_return);

        csParser.expression_return expression416 = default(csParser.expression_return);

        csParser.expression_return expression418 = default(csParser.expression_return);


        object char_literal415_tree=null;
        object char_literal417_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 110) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:451:23: ( null_coalescing_expression ( '?' expression ':' expression )? )
            // G:\\downloads\\antlr\\cs.g:452:2: null_coalescing_expression ( '?' expression ':' expression )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_null_coalescing_expression_in_conditional_expression3211);
            	null_coalescing_expression414 = null_coalescing_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, null_coalescing_expression414.Tree);
            	// G:\\downloads\\antlr\\cs.g:452:31: ( '?' expression ':' expression )?
            	int alt120 = 2;
            	int LA120_0 = input.LA(1);

            	if ( (LA120_0 == 101) )
            	{
            	    alt120 = 1;
            	}
            	switch (alt120) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:452:32: '?' expression ':' expression
            	        {
            	        	char_literal415=(IToken)Match(input,101,FOLLOW_101_in_conditional_expression3216); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal415_tree = (object)adaptor.Create(char_literal415);
            	        		adaptor.AddChild(root_0, char_literal415_tree);
            	        	}
            	        	PushFollow(FOLLOW_expression_in_conditional_expression3220);
            	        	expression416 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression416.Tree);
            	        	char_literal417=(IToken)Match(input,90,FOLLOW_90_in_conditional_expression3224); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal417_tree = (object)adaptor.Create(char_literal417);
            	        		adaptor.AddChild(root_0, char_literal417_tree);
            	        	}
            	        	PushFollow(FOLLOW_expression_in_conditional_expression3228);
            	        	expression418 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression418.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 110, conditional_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "conditional_expression"

    public class lambda_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "lambda_expression"
    // G:\\downloads\\antlr\\cs.g:457:1: lambda_expression : anonymous_function_signature '=>' anonymous_function_body ;
    public csParser.lambda_expression_return lambda_expression() // throws RecognitionException [1]
    {   
        csParser.lambda_expression_return retval = new csParser.lambda_expression_return();
        retval.Start = input.LT(1);
        int lambda_expression_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal420 = null;
        csParser.anonymous_function_signature_return anonymous_function_signature419 = default(csParser.anonymous_function_signature_return);

        csParser.anonymous_function_body_return anonymous_function_body421 = default(csParser.anonymous_function_body_return);


        object string_literal420_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 111) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:457:18: ( anonymous_function_signature '=>' anonymous_function_body )
            // G:\\downloads\\antlr\\cs.g:458:2: anonymous_function_signature '=>' anonymous_function_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_anonymous_function_signature_in_lambda_expression3248);
            	anonymous_function_signature419 = anonymous_function_signature();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_function_signature419.Tree);
            	string_literal420=(IToken)Match(input,131,FOLLOW_131_in_lambda_expression3252); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal420_tree = (object)adaptor.Create(string_literal420);
            		adaptor.AddChild(root_0, string_literal420_tree);
            	}
            	PushFollow(FOLLOW_anonymous_function_body_in_lambda_expression3256);
            	anonymous_function_body421 = anonymous_function_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, anonymous_function_body421.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 111, lambda_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "lambda_expression"

    public class anonymous_function_signature_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "anonymous_function_signature"
    // G:\\downloads\\antlr\\cs.g:459:1: anonymous_function_signature : ( '(' ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )? ')' | implicit_anonymous_function_parameter_list );
    public csParser.anonymous_function_signature_return anonymous_function_signature() // throws RecognitionException [1]
    {   
        csParser.anonymous_function_signature_return retval = new csParser.anonymous_function_signature_return();
        retval.Start = input.LT(1);
        int anonymous_function_signature_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal422 = null;
        IToken char_literal425 = null;
        csParser.explicit_anonymous_function_parameter_list_return explicit_anonymous_function_parameter_list423 = default(csParser.explicit_anonymous_function_parameter_list_return);

        csParser.implicit_anonymous_function_parameter_list_return implicit_anonymous_function_parameter_list424 = default(csParser.implicit_anonymous_function_parameter_list_return);

        csParser.implicit_anonymous_function_parameter_list_return implicit_anonymous_function_parameter_list426 = default(csParser.implicit_anonymous_function_parameter_list_return);


        object char_literal422_tree=null;
        object char_literal425_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 112) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:459:29: ( '(' ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )? ')' | implicit_anonymous_function_parameter_list )
            int alt122 = 2;
            int LA122_0 = input.LA(1);

            if ( (LA122_0 == 88) )
            {
                alt122 = 1;
            }
            else if ( (LA122_0 == IDENTIFIER || LA122_0 == 65 || (LA122_0 >= 132 && LA122_0 <= 133) || (LA122_0 >= 135 && LA122_0 <= 148) || (LA122_0 >= 150 && LA122_0 <= 152) || LA122_0 == 154 || (LA122_0 >= 157 && LA122_0 <= 159) || LA122_0 == 170 || (LA122_0 >= 177 && LA122_0 <= 178) || LA122_0 == 195 || LA122_0 == 202) )
            {
                alt122 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d122s0 =
                    new NoViableAltException("", 122, 0, input);

                throw nvae_d122s0;
            }
            switch (alt122) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:460:2: '(' ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )? ')'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal422=(IToken)Match(input,88,FOLLOW_88_in_anonymous_function_signature3263); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal422_tree = (object)adaptor.Create(char_literal422);
                    		adaptor.AddChild(root_0, char_literal422_tree);
                    	}
                    	// G:\\downloads\\antlr\\cs.g:460:6: ( explicit_anonymous_function_parameter_list | implicit_anonymous_function_parameter_list )?
                    	int alt121 = 3;
                    	int LA121_0 = input.LA(1);

                    	if ( (LA121_0 == 82 || (LA121_0 >= 91 && LA121_0 <= 92) || (LA121_0 >= 160 && LA121_0 <= 168) || (LA121_0 >= 196 && LA121_0 <= 201)) )
                    	{
                    	    alt121 = 1;
                    	}
                    	else if ( (LA121_0 == IDENTIFIER || LA121_0 == 65 || (LA121_0 >= 132 && LA121_0 <= 133) || (LA121_0 >= 135 && LA121_0 <= 148) || (LA121_0 >= 150 && LA121_0 <= 152) || LA121_0 == 154 || (LA121_0 >= 157 && LA121_0 <= 159) || LA121_0 == 170 || (LA121_0 >= 177 && LA121_0 <= 178) || LA121_0 == 195 || LA121_0 == 202) )
                    	{
                    	    int LA121_2 = input.LA(2);

                    	    if ( (LA121_2 == IDENTIFIER || LA121_2 == DOT || LA121_2 == 65 || LA121_2 == 84 || LA121_2 == 86 || (LA121_2 >= 99 && LA121_2 <= 101) || (LA121_2 >= 132 && LA121_2 <= 133) || (LA121_2 >= 135 && LA121_2 <= 148) || (LA121_2 >= 150 && LA121_2 <= 152) || LA121_2 == 154 || (LA121_2 >= 157 && LA121_2 <= 159) || LA121_2 == 170 || (LA121_2 >= 177 && LA121_2 <= 178) || LA121_2 == 195 || LA121_2 == 202) )
                    	    {
                    	        alt121 = 1;
                    	    }
                    	    else if ( (LA121_2 == RPAREN || LA121_2 == 89) )
                    	    {
                    	        alt121 = 2;
                    	    }
                    	}
                    	switch (alt121) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:460:7: explicit_anonymous_function_parameter_list
                    	        {
                    	        	PushFollow(FOLLOW_explicit_anonymous_function_parameter_list_in_anonymous_function_signature3266);
                    	        	explicit_anonymous_function_parameter_list423 = explicit_anonymous_function_parameter_list();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, explicit_anonymous_function_parameter_list423.Tree);

                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:461:5: implicit_anonymous_function_parameter_list
                    	        {
                    	        	PushFollow(FOLLOW_implicit_anonymous_function_parameter_list_in_anonymous_function_signature3272);
                    	        	implicit_anonymous_function_parameter_list424 = implicit_anonymous_function_parameter_list();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter_list424.Tree);

                    	        }
                    	        break;

                    	}

                    	char_literal425=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_anonymous_function_signature3276); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal425_tree = (object)adaptor.Create(char_literal425);
                    		adaptor.AddChild(root_0, char_literal425_tree);
                    	}

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:462:4: implicit_anonymous_function_parameter_list
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_implicit_anonymous_function_parameter_list_in_anonymous_function_signature3281);
                    	implicit_anonymous_function_parameter_list426 = implicit_anonymous_function_parameter_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter_list426.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 112, anonymous_function_signature_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "anonymous_function_signature"

    public class implicit_anonymous_function_parameter_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "implicit_anonymous_function_parameter_list"
    // G:\\downloads\\antlr\\cs.g:464:1: implicit_anonymous_function_parameter_list : implicit_anonymous_function_parameter ( ',' implicit_anonymous_function_parameter )* ;
    public csParser.implicit_anonymous_function_parameter_list_return implicit_anonymous_function_parameter_list() // throws RecognitionException [1]
    {   
        csParser.implicit_anonymous_function_parameter_list_return retval = new csParser.implicit_anonymous_function_parameter_list_return();
        retval.Start = input.LT(1);
        int implicit_anonymous_function_parameter_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal428 = null;
        csParser.implicit_anonymous_function_parameter_return implicit_anonymous_function_parameter427 = default(csParser.implicit_anonymous_function_parameter_return);

        csParser.implicit_anonymous_function_parameter_return implicit_anonymous_function_parameter429 = default(csParser.implicit_anonymous_function_parameter_return);


        object char_literal428_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 113) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:464:43: ( implicit_anonymous_function_parameter ( ',' implicit_anonymous_function_parameter )* )
            // G:\\downloads\\antlr\\cs.g:465:2: implicit_anonymous_function_parameter ( ',' implicit_anonymous_function_parameter )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3290);
            	implicit_anonymous_function_parameter427 = implicit_anonymous_function_parameter();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter427.Tree);
            	// G:\\downloads\\antlr\\cs.g:465:42: ( ',' implicit_anonymous_function_parameter )*
            	do 
            	{
            	    int alt123 = 2;
            	    int LA123_0 = input.LA(1);

            	    if ( (LA123_0 == 89) )
            	    {
            	        alt123 = 1;
            	    }


            	    switch (alt123) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:465:43: ',' implicit_anonymous_function_parameter
            			    {
            			    	char_literal428=(IToken)Match(input,89,FOLLOW_89_in_implicit_anonymous_function_parameter_list3295); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal428_tree = (object)adaptor.Create(char_literal428);
            			    		adaptor.AddChild(root_0, char_literal428_tree);
            			    	}
            			    	PushFollow(FOLLOW_implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3299);
            			    	implicit_anonymous_function_parameter429 = implicit_anonymous_function_parameter();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, implicit_anonymous_function_parameter429.Tree);

            			    }
            			    break;

            			default:
            			    goto loop123;
            	    }
            	} while (true);

            	loop123:
            		;	// Stops C# compiler whining that label 'loop123' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 113, implicit_anonymous_function_parameter_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "implicit_anonymous_function_parameter_list"

    public class implicit_anonymous_function_parameter_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "implicit_anonymous_function_parameter"
    // G:\\downloads\\antlr\\cs.g:466:1: implicit_anonymous_function_parameter : identifier ;
    public csParser.implicit_anonymous_function_parameter_return implicit_anonymous_function_parameter() // throws RecognitionException [1]
    {   
        csParser.implicit_anonymous_function_parameter_return retval = new csParser.implicit_anonymous_function_parameter_return();
        retval.Start = input.LT(1);
        int implicit_anonymous_function_parameter_StartIndex = input.Index();
        object root_0 = null;

        csParser.identifier_return identifier430 = default(csParser.identifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 114) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:466:38: ( identifier )
            // G:\\downloads\\antlr\\cs.g:467:2: identifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_implicit_anonymous_function_parameter3309);
            	identifier430 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier430.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 114, implicit_anonymous_function_parameter_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "implicit_anonymous_function_parameter"

    public class anonymous_function_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "anonymous_function_body"
    // G:\\downloads\\antlr\\cs.g:468:1: anonymous_function_body : ( expression | block );
    public csParser.anonymous_function_body_return anonymous_function_body() // throws RecognitionException [1]
    {   
        csParser.anonymous_function_body_return retval = new csParser.anonymous_function_body_return();
        retval.Start = input.LT(1);
        int anonymous_function_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression431 = default(csParser.expression_return);

        csParser.block_return block432 = default(csParser.block_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 115) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:468:24: ( expression | block )
            int alt124 = 2;
            int LA124_0 = input.LA(1);

            if ( ((LA124_0 >= IDENTIFIER && LA124_0 <= NULL) || LA124_0 == MINUS || LA124_0 == 65 || LA124_0 == 68 || LA124_0 == 83 || LA124_0 == 85 || LA124_0 == 88 || (LA124_0 >= 93 && LA124_0 <= 98) || LA124_0 == 100 || (LA124_0 >= 102 && LA124_0 <= 106) || LA124_0 == 117 || (LA124_0 >= 132 && LA124_0 <= 133) || (LA124_0 >= 135 && LA124_0 <= 148) || (LA124_0 >= 150 && LA124_0 <= 152) || LA124_0 == 154 || (LA124_0 >= 157 && LA124_0 <= 168) || LA124_0 == 170 || (LA124_0 >= 177 && LA124_0 <= 178) || (LA124_0 >= 195 && LA124_0 <= 202)) )
            {
                alt124 = 1;
            }
            else if ( (LA124_0 == SEMI || LA124_0 == 62) )
            {
                alt124 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d124s0 =
                    new NoViableAltException("", 124, 0, input);

                throw nvae_d124s0;
            }
            switch (alt124) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:469:2: expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_in_anonymous_function_body3316);
                    	expression431 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression431.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:470:4: block
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_block_in_anonymous_function_body3321);
                    	block432 = block();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block432.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 115, anonymous_function_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "anonymous_function_body"

    public class query_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "query_expression"
    // G:\\downloads\\antlr\\cs.g:475:1: query_expression : from_clause query_body ;
    public csParser.query_expression_return query_expression() // throws RecognitionException [1]
    {   
        csParser.query_expression_return retval = new csParser.query_expression_return();
        retval.Start = input.LT(1);
        int query_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.from_clause_return from_clause433 = default(csParser.from_clause_return);

        csParser.query_body_return query_body434 = default(csParser.query_body_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 116) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:475:17: ( from_clause query_body )
            // G:\\downloads\\antlr\\cs.g:476:2: from_clause query_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_from_clause_in_query_expression3333);
            	from_clause433 = from_clause();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, from_clause433.Tree);
            	PushFollow(FOLLOW_query_body_in_query_expression3337);
            	query_body434 = query_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body434.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 116, query_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "query_expression"

    public class query_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "query_body"
    // G:\\downloads\\antlr\\cs.g:477:1: query_body : ( query_body_clauses )? select_or_group_clause ( ( 'into' )=> query_continuation )? ;
    public csParser.query_body_return query_body() // throws RecognitionException [1]
    {   
        csParser.query_body_return retval = new csParser.query_body_return();
        retval.Start = input.LT(1);
        int query_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.query_body_clauses_return query_body_clauses435 = default(csParser.query_body_clauses_return);

        csParser.select_or_group_clause_return select_or_group_clause436 = default(csParser.select_or_group_clause_return);

        csParser.query_continuation_return query_continuation437 = default(csParser.query_continuation_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 117) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:477:11: ( ( query_body_clauses )? select_or_group_clause ( ( 'into' )=> query_continuation )? )
            // G:\\downloads\\antlr\\cs.g:479:2: ( query_body_clauses )? select_or_group_clause ( ( 'into' )=> query_continuation )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:479:2: ( query_body_clauses )?
            	int alt125 = 2;
            	int LA125_0 = input.LA(1);

            	if ( (LA125_0 == 133 || LA125_0 == 135 || (LA125_0 >= 138 && LA125_0 <= 139) || LA125_0 == 145) )
            	{
            	    alt125 = 1;
            	}
            	switch (alt125) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:479:2: query_body_clauses
            	        {
            	        	PushFollow(FOLLOW_query_body_clauses_in_query_body3347);
            	        	query_body_clauses435 = query_body_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body_clauses435.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_select_or_group_clause_in_query_body3352);
            	select_or_group_clause436 = select_or_group_clause();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, select_or_group_clause436.Tree);
            	// G:\\downloads\\antlr\\cs.g:479:49: ( ( 'into' )=> query_continuation )?
            	int alt126 = 2;
            	int LA126_0 = input.LA(1);

            	if ( (LA126_0 == 132) )
            	{
            	    int LA126_1 = input.LA(2);

            	    if ( (synpred23_cs()) )
            	    {
            	        alt126 = 1;
            	    }
            	}
            	switch (alt126) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:479:50: ( 'into' )=> query_continuation
            	        {
            	        	PushFollow(FOLLOW_query_continuation_in_query_body3363);
            	        	query_continuation437 = query_continuation();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_continuation437.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 117, query_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "query_body"

    public class query_continuation_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "query_continuation"
    // G:\\downloads\\antlr\\cs.g:480:1: query_continuation : 'into' identifier query_body ;
    public csParser.query_continuation_return query_continuation() // throws RecognitionException [1]
    {   
        csParser.query_continuation_return retval = new csParser.query_continuation_return();
        retval.Start = input.LT(1);
        int query_continuation_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal438 = null;
        csParser.identifier_return identifier439 = default(csParser.identifier_return);

        csParser.query_body_return query_body440 = default(csParser.query_body_return);


        object string_literal438_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 118) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:480:19: ( 'into' identifier query_body )
            // G:\\downloads\\antlr\\cs.g:481:2: 'into' identifier query_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal438=(IToken)Match(input,132,FOLLOW_132_in_query_continuation3373); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal438_tree = (object)adaptor.Create(string_literal438);
            		adaptor.AddChild(root_0, string_literal438_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_query_continuation3377);
            	identifier439 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier439.Tree);
            	PushFollow(FOLLOW_query_body_in_query_continuation3381);
            	query_body440 = query_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body440.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 118, query_continuation_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "query_continuation"

    public class query_body_clauses_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "query_body_clauses"
    // G:\\downloads\\antlr\\cs.g:482:1: query_body_clauses : ( query_body_clause )+ ;
    public csParser.query_body_clauses_return query_body_clauses() // throws RecognitionException [1]
    {   
        csParser.query_body_clauses_return retval = new csParser.query_body_clauses_return();
        retval.Start = input.LT(1);
        int query_body_clauses_StartIndex = input.Index();
        object root_0 = null;

        csParser.query_body_clause_return query_body_clause441 = default(csParser.query_body_clause_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 119) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:482:19: ( ( query_body_clause )+ )
            // G:\\downloads\\antlr\\cs.g:483:2: ( query_body_clause )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:483:2: ( query_body_clause )+
            	int cnt127 = 0;
            	do 
            	{
            	    int alt127 = 2;
            	    int LA127_0 = input.LA(1);

            	    if ( (LA127_0 == 133 || LA127_0 == 135 || (LA127_0 >= 138 && LA127_0 <= 139) || LA127_0 == 145) )
            	    {
            	        alt127 = 1;
            	    }


            	    switch (alt127) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:483:2: query_body_clause
            			    {
            			    	PushFollow(FOLLOW_query_body_clause_in_query_body_clauses3388);
            			    	query_body_clause441 = query_body_clause();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, query_body_clause441.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt127 >= 1 ) goto loop127;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(127, input);
            		            throw eee;
            	    }
            	    cnt127++;
            	} while (true);

            	loop127:
            		;	// Stops C# compiler whinging that label 'loop127' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 119, query_body_clauses_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "query_body_clauses"

    public class query_body_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "query_body_clause"
    // G:\\downloads\\antlr\\cs.g:484:1: query_body_clause : ( from_clause | let_clause | where_clause | join_clause | orderby_clause );
    public csParser.query_body_clause_return query_body_clause() // throws RecognitionException [1]
    {   
        csParser.query_body_clause_return retval = new csParser.query_body_clause_return();
        retval.Start = input.LT(1);
        int query_body_clause_StartIndex = input.Index();
        object root_0 = null;

        csParser.from_clause_return from_clause442 = default(csParser.from_clause_return);

        csParser.let_clause_return let_clause443 = default(csParser.let_clause_return);

        csParser.where_clause_return where_clause444 = default(csParser.where_clause_return);

        csParser.join_clause_return join_clause445 = default(csParser.join_clause_return);

        csParser.orderby_clause_return orderby_clause446 = default(csParser.orderby_clause_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 120) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:484:18: ( from_clause | let_clause | where_clause | join_clause | orderby_clause )
            int alt128 = 5;
            switch ( input.LA(1) ) 
            {
            case 133:
            	{
                alt128 = 1;
                }
                break;
            case 138:
            	{
                alt128 = 2;
                }
                break;
            case 145:
            	{
                alt128 = 3;
                }
                break;
            case 135:
            	{
                alt128 = 4;
                }
                break;
            case 139:
            	{
                alt128 = 5;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d128s0 =
            	        new NoViableAltException("", 128, 0, input);

            	    throw nvae_d128s0;
            }

            switch (alt128) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:485:2: from_clause
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_from_clause_in_query_body_clause3397);
                    	from_clause442 = from_clause();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, from_clause442.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:486:4: let_clause
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_let_clause_in_query_body_clause3402);
                    	let_clause443 = let_clause();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, let_clause443.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:487:4: where_clause
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_where_clause_in_query_body_clause3407);
                    	where_clause444 = where_clause();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, where_clause444.Tree);

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:488:4: join_clause
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_join_clause_in_query_body_clause3412);
                    	join_clause445 = join_clause();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, join_clause445.Tree);

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:489:4: orderby_clause
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_orderby_clause_in_query_body_clause3417);
                    	orderby_clause446 = orderby_clause();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, orderby_clause446.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 120, query_body_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "query_body_clause"

    public class from_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "from_clause"
    // G:\\downloads\\antlr\\cs.g:490:1: from_clause : 'from' ( type )? identifier 'in' expression ;
    public csParser.from_clause_return from_clause() // throws RecognitionException [1]
    {   
        csParser.from_clause_return retval = new csParser.from_clause_return();
        retval.Start = input.LT(1);
        int from_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal447 = null;
        IToken string_literal450 = null;
        csParser.type_return type448 = default(csParser.type_return);

        csParser.identifier_return identifier449 = default(csParser.identifier_return);

        csParser.expression_return expression451 = default(csParser.expression_return);


        object string_literal447_tree=null;
        object string_literal450_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 121) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:490:12: ( 'from' ( type )? identifier 'in' expression )
            // G:\\downloads\\antlr\\cs.g:491:2: 'from' ( type )? identifier 'in' expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal447=(IToken)Match(input,133,FOLLOW_133_in_from_clause3424); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal447_tree = (object)adaptor.Create(string_literal447);
            		adaptor.AddChild(root_0, string_literal447_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:491:11: ( type )?
            	int alt129 = 2;
            	int LA129_0 = input.LA(1);

            	if ( (LA129_0 == 82 || (LA129_0 >= 160 && LA129_0 <= 168) || (LA129_0 >= 196 && LA129_0 <= 201)) )
            	{
            	    alt129 = 1;
            	}
            	else if ( (LA129_0 == IDENTIFIER || LA129_0 == 65 || (LA129_0 >= 132 && LA129_0 <= 133) || (LA129_0 >= 135 && LA129_0 <= 148) || (LA129_0 >= 150 && LA129_0 <= 152) || LA129_0 == 154 || (LA129_0 >= 157 && LA129_0 <= 159) || LA129_0 == 170 || (LA129_0 >= 177 && LA129_0 <= 178) || LA129_0 == 195 || LA129_0 == 202) )
            	{
            	    int LA129_2 = input.LA(2);

            	    if ( (LA129_2 == IDENTIFIER || LA129_2 == DOT || LA129_2 == 65 || LA129_2 == 84 || LA129_2 == 86 || (LA129_2 >= 99 && LA129_2 <= 101) || (LA129_2 >= 132 && LA129_2 <= 133) || (LA129_2 >= 135 && LA129_2 <= 148) || (LA129_2 >= 150 && LA129_2 <= 152) || LA129_2 == 154 || (LA129_2 >= 157 && LA129_2 <= 159) || LA129_2 == 170 || (LA129_2 >= 177 && LA129_2 <= 178) || LA129_2 == 195 || LA129_2 == 202) )
            	    {
            	        alt129 = 1;
            	    }
            	}
            	switch (alt129) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:491:11: type
            	        {
            	        	PushFollow(FOLLOW_type_in_from_clause3428);
            	        	type448 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type448.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_identifier_in_from_clause3433);
            	identifier449 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier449.Tree);
            	string_literal450=(IToken)Match(input,134,FOLLOW_134_in_from_clause3437); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal450_tree = (object)adaptor.Create(string_literal450);
            		adaptor.AddChild(root_0, string_literal450_tree);
            	}
            	PushFollow(FOLLOW_expression_in_from_clause3441);
            	expression451 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression451.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 121, from_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "from_clause"

    public class join_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "join_clause"
    // G:\\downloads\\antlr\\cs.g:492:1: join_clause : 'join' ( type )? identifier 'in' expression 'on' expression 'equals' expression ( 'into' identifier )? ;
    public csParser.join_clause_return join_clause() // throws RecognitionException [1]
    {   
        csParser.join_clause_return retval = new csParser.join_clause_return();
        retval.Start = input.LT(1);
        int join_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal452 = null;
        IToken string_literal455 = null;
        IToken string_literal457 = null;
        IToken string_literal459 = null;
        IToken string_literal461 = null;
        csParser.type_return type453 = default(csParser.type_return);

        csParser.identifier_return identifier454 = default(csParser.identifier_return);

        csParser.expression_return expression456 = default(csParser.expression_return);

        csParser.expression_return expression458 = default(csParser.expression_return);

        csParser.expression_return expression460 = default(csParser.expression_return);

        csParser.identifier_return identifier462 = default(csParser.identifier_return);


        object string_literal452_tree=null;
        object string_literal455_tree=null;
        object string_literal457_tree=null;
        object string_literal459_tree=null;
        object string_literal461_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 122) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:492:12: ( 'join' ( type )? identifier 'in' expression 'on' expression 'equals' expression ( 'into' identifier )? )
            // G:\\downloads\\antlr\\cs.g:493:2: 'join' ( type )? identifier 'in' expression 'on' expression 'equals' expression ( 'into' identifier )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal452=(IToken)Match(input,135,FOLLOW_135_in_join_clause3449); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal452_tree = (object)adaptor.Create(string_literal452);
            		adaptor.AddChild(root_0, string_literal452_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:493:11: ( type )?
            	int alt130 = 2;
            	int LA130_0 = input.LA(1);

            	if ( (LA130_0 == 82 || (LA130_0 >= 160 && LA130_0 <= 168) || (LA130_0 >= 196 && LA130_0 <= 201)) )
            	{
            	    alt130 = 1;
            	}
            	else if ( (LA130_0 == IDENTIFIER || LA130_0 == 65 || (LA130_0 >= 132 && LA130_0 <= 133) || (LA130_0 >= 135 && LA130_0 <= 148) || (LA130_0 >= 150 && LA130_0 <= 152) || LA130_0 == 154 || (LA130_0 >= 157 && LA130_0 <= 159) || LA130_0 == 170 || (LA130_0 >= 177 && LA130_0 <= 178) || LA130_0 == 195 || LA130_0 == 202) )
            	{
            	    int LA130_2 = input.LA(2);

            	    if ( (LA130_2 == IDENTIFIER || LA130_2 == DOT || LA130_2 == 65 || LA130_2 == 84 || LA130_2 == 86 || (LA130_2 >= 99 && LA130_2 <= 101) || (LA130_2 >= 132 && LA130_2 <= 133) || (LA130_2 >= 135 && LA130_2 <= 148) || (LA130_2 >= 150 && LA130_2 <= 152) || LA130_2 == 154 || (LA130_2 >= 157 && LA130_2 <= 159) || LA130_2 == 170 || (LA130_2 >= 177 && LA130_2 <= 178) || LA130_2 == 195 || LA130_2 == 202) )
            	    {
            	        alt130 = 1;
            	    }
            	}
            	switch (alt130) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:493:11: type
            	        {
            	        	PushFollow(FOLLOW_type_in_join_clause3453);
            	        	type453 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type453.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_identifier_in_join_clause3458);
            	identifier454 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier454.Tree);
            	string_literal455=(IToken)Match(input,134,FOLLOW_134_in_join_clause3462); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal455_tree = (object)adaptor.Create(string_literal455);
            		adaptor.AddChild(root_0, string_literal455_tree);
            	}
            	PushFollow(FOLLOW_expression_in_join_clause3466);
            	expression456 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression456.Tree);
            	string_literal457=(IToken)Match(input,136,FOLLOW_136_in_join_clause3470); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal457_tree = (object)adaptor.Create(string_literal457);
            		adaptor.AddChild(root_0, string_literal457_tree);
            	}
            	PushFollow(FOLLOW_expression_in_join_clause3474);
            	expression458 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression458.Tree);
            	string_literal459=(IToken)Match(input,137,FOLLOW_137_in_join_clause3478); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal459_tree = (object)adaptor.Create(string_literal459);
            		adaptor.AddChild(root_0, string_literal459_tree);
            	}
            	PushFollow(FOLLOW_expression_in_join_clause3482);
            	expression460 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression460.Tree);
            	// G:\\downloads\\antlr\\cs.g:493:94: ( 'into' identifier )?
            	int alt131 = 2;
            	int LA131_0 = input.LA(1);

            	if ( (LA131_0 == 132) )
            	{
            	    alt131 = 1;
            	}
            	switch (alt131) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:493:95: 'into' identifier
            	        {
            	        	string_literal461=(IToken)Match(input,132,FOLLOW_132_in_join_clause3485); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal461_tree = (object)adaptor.Create(string_literal461);
            	        		adaptor.AddChild(root_0, string_literal461_tree);
            	        	}
            	        	PushFollow(FOLLOW_identifier_in_join_clause3487);
            	        	identifier462 = identifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier462.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 122, join_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "join_clause"

    public class let_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "let_clause"
    // G:\\downloads\\antlr\\cs.g:494:1: let_clause : 'let' identifier '=' expression ;
    public csParser.let_clause_return let_clause() // throws RecognitionException [1]
    {   
        csParser.let_clause_return retval = new csParser.let_clause_return();
        retval.Start = input.LT(1);
        int let_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal463 = null;
        IToken char_literal465 = null;
        csParser.identifier_return identifier464 = default(csParser.identifier_return);

        csParser.expression_return expression466 = default(csParser.expression_return);


        object string_literal463_tree=null;
        object char_literal465_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 123) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:494:11: ( 'let' identifier '=' expression )
            // G:\\downloads\\antlr\\cs.g:495:2: 'let' identifier '=' expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal463=(IToken)Match(input,138,FOLLOW_138_in_let_clause3497); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal463_tree = (object)adaptor.Create(string_literal463);
            		adaptor.AddChild(root_0, string_literal463_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_let_clause3501);
            	identifier464 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier464.Tree);
            	char_literal465=(IToken)Match(input,66,FOLLOW_66_in_let_clause3505); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal465_tree = (object)adaptor.Create(char_literal465);
            		adaptor.AddChild(root_0, char_literal465_tree);
            	}
            	PushFollow(FOLLOW_expression_in_let_clause3509);
            	expression466 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression466.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 123, let_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "let_clause"

    public class orderby_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "orderby_clause"
    // G:\\downloads\\antlr\\cs.g:496:1: orderby_clause : 'orderby' ordering_list ;
    public csParser.orderby_clause_return orderby_clause() // throws RecognitionException [1]
    {   
        csParser.orderby_clause_return retval = new csParser.orderby_clause_return();
        retval.Start = input.LT(1);
        int orderby_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal467 = null;
        csParser.ordering_list_return ordering_list468 = default(csParser.ordering_list_return);


        object string_literal467_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 124) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:496:15: ( 'orderby' ordering_list )
            // G:\\downloads\\antlr\\cs.g:497:2: 'orderby' ordering_list
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal467=(IToken)Match(input,139,FOLLOW_139_in_orderby_clause3516); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal467_tree = (object)adaptor.Create(string_literal467);
            		adaptor.AddChild(root_0, string_literal467_tree);
            	}
            	PushFollow(FOLLOW_ordering_list_in_orderby_clause3520);
            	ordering_list468 = ordering_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering_list468.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 124, orderby_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "orderby_clause"

    public class ordering_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "ordering_list"
    // G:\\downloads\\antlr\\cs.g:498:1: ordering_list : ordering ( ',' ordering )* ;
    public csParser.ordering_list_return ordering_list() // throws RecognitionException [1]
    {   
        csParser.ordering_list_return retval = new csParser.ordering_list_return();
        retval.Start = input.LT(1);
        int ordering_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal470 = null;
        csParser.ordering_return ordering469 = default(csParser.ordering_return);

        csParser.ordering_return ordering471 = default(csParser.ordering_return);


        object char_literal470_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 125) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:498:14: ( ordering ( ',' ordering )* )
            // G:\\downloads\\antlr\\cs.g:499:2: ordering ( ',' ordering )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_ordering_in_ordering_list3528);
            	ordering469 = ordering();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering469.Tree);
            	// G:\\downloads\\antlr\\cs.g:499:13: ( ',' ordering )*
            	do 
            	{
            	    int alt132 = 2;
            	    int LA132_0 = input.LA(1);

            	    if ( (LA132_0 == 89) )
            	    {
            	        alt132 = 1;
            	    }


            	    switch (alt132) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:499:14: ',' ordering
            			    {
            			    	char_literal470=(IToken)Match(input,89,FOLLOW_89_in_ordering_list3533); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal470_tree = (object)adaptor.Create(char_literal470);
            			    		adaptor.AddChild(root_0, char_literal470_tree);
            			    	}
            			    	PushFollow(FOLLOW_ordering_in_ordering_list3537);
            			    	ordering471 = ordering();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering471.Tree);

            			    }
            			    break;

            			default:
            			    goto loop132;
            	    }
            	} while (true);

            	loop132:
            		;	// Stops C# compiler whining that label 'loop132' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 125, ordering_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "ordering_list"

    public class ordering_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "ordering"
    // G:\\downloads\\antlr\\cs.g:500:1: ordering : expression ordering_direction ;
    public csParser.ordering_return ordering() // throws RecognitionException [1]
    {   
        csParser.ordering_return retval = new csParser.ordering_return();
        retval.Start = input.LT(1);
        int ordering_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression472 = default(csParser.expression_return);

        csParser.ordering_direction_return ordering_direction473 = default(csParser.ordering_direction_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 126) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:500:9: ( expression ordering_direction )
            // G:\\downloads\\antlr\\cs.g:501:2: expression ordering_direction
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_ordering3547);
            	expression472 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression472.Tree);
            	PushFollow(FOLLOW_ordering_direction_in_ordering3552);
            	ordering_direction473 = ordering_direction();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ordering_direction473.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 126, ordering_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "ordering"

    public class ordering_direction_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "ordering_direction"
    // G:\\downloads\\antlr\\cs.g:503:1: ordering_direction : ( 'ascending' | 'descending' );
    public csParser.ordering_direction_return ordering_direction() // throws RecognitionException [1]
    {   
        csParser.ordering_direction_return retval = new csParser.ordering_direction_return();
        retval.Start = input.LT(1);
        int ordering_direction_StartIndex = input.Index();
        object root_0 = null;

        IToken set474 = null;

        object set474_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 127) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:503:19: ( 'ascending' | 'descending' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set474 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 140 && input.LA(1) <= 141) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set474));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 127, ordering_direction_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "ordering_direction"

    public class select_or_group_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "select_or_group_clause"
    // G:\\downloads\\antlr\\cs.g:506:1: select_or_group_clause : ( select_clause | group_clause );
    public csParser.select_or_group_clause_return select_or_group_clause() // throws RecognitionException [1]
    {   
        csParser.select_or_group_clause_return retval = new csParser.select_or_group_clause_return();
        retval.Start = input.LT(1);
        int select_or_group_clause_StartIndex = input.Index();
        object root_0 = null;

        csParser.select_clause_return select_clause475 = default(csParser.select_clause_return);

        csParser.group_clause_return group_clause476 = default(csParser.group_clause_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 128) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:506:23: ( select_clause | group_clause )
            int alt133 = 2;
            int LA133_0 = input.LA(1);

            if ( (LA133_0 == 142) )
            {
                alt133 = 1;
            }
            else if ( (LA133_0 == 143) )
            {
                alt133 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d133s0 =
                    new NoViableAltException("", 133, 0, input);

                throw nvae_d133s0;
            }
            switch (alt133) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:507:2: select_clause
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_select_clause_in_select_or_group_clause3574);
                    	select_clause475 = select_clause();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, select_clause475.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:508:4: group_clause
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_group_clause_in_select_or_group_clause3579);
                    	group_clause476 = group_clause();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, group_clause476.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 128, select_or_group_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "select_or_group_clause"

    public class select_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "select_clause"
    // G:\\downloads\\antlr\\cs.g:509:1: select_clause : 'select' expression ;
    public csParser.select_clause_return select_clause() // throws RecognitionException [1]
    {   
        csParser.select_clause_return retval = new csParser.select_clause_return();
        retval.Start = input.LT(1);
        int select_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal477 = null;
        csParser.expression_return expression478 = default(csParser.expression_return);


        object string_literal477_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 129) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:509:14: ( 'select' expression )
            // G:\\downloads\\antlr\\cs.g:510:2: 'select' expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal477=(IToken)Match(input,142,FOLLOW_142_in_select_clause3587); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal477_tree = (object)adaptor.Create(string_literal477);
            		adaptor.AddChild(root_0, string_literal477_tree);
            	}
            	PushFollow(FOLLOW_expression_in_select_clause3591);
            	expression478 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression478.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 129, select_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "select_clause"

    public class group_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "group_clause"
    // G:\\downloads\\antlr\\cs.g:511:1: group_clause : 'group' expression 'by' expression ;
    public csParser.group_clause_return group_clause() // throws RecognitionException [1]
    {   
        csParser.group_clause_return retval = new csParser.group_clause_return();
        retval.Start = input.LT(1);
        int group_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal479 = null;
        IToken string_literal481 = null;
        csParser.expression_return expression480 = default(csParser.expression_return);

        csParser.expression_return expression482 = default(csParser.expression_return);


        object string_literal479_tree=null;
        object string_literal481_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 130) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:511:13: ( 'group' expression 'by' expression )
            // G:\\downloads\\antlr\\cs.g:512:2: 'group' expression 'by' expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal479=(IToken)Match(input,143,FOLLOW_143_in_group_clause3599); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal479_tree = (object)adaptor.Create(string_literal479);
            		adaptor.AddChild(root_0, string_literal479_tree);
            	}
            	PushFollow(FOLLOW_expression_in_group_clause3603);
            	expression480 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression480.Tree);
            	string_literal481=(IToken)Match(input,144,FOLLOW_144_in_group_clause3607); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal481_tree = (object)adaptor.Create(string_literal481);
            		adaptor.AddChild(root_0, string_literal481_tree);
            	}
            	PushFollow(FOLLOW_expression_in_group_clause3611);
            	expression482 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression482.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 130, group_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "group_clause"

    public class where_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "where_clause"
    // G:\\downloads\\antlr\\cs.g:513:1: where_clause : 'where' boolean_expression ;
    public csParser.where_clause_return where_clause() // throws RecognitionException [1]
    {   
        csParser.where_clause_return retval = new csParser.where_clause_return();
        retval.Start = input.LT(1);
        int where_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal483 = null;
        csParser.boolean_expression_return boolean_expression484 = default(csParser.boolean_expression_return);


        object string_literal483_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 131) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:513:13: ( 'where' boolean_expression )
            // G:\\downloads\\antlr\\cs.g:514:2: 'where' boolean_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal483=(IToken)Match(input,145,FOLLOW_145_in_where_clause3619); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal483_tree = (object)adaptor.Create(string_literal483);
            		adaptor.AddChild(root_0, string_literal483_tree);
            	}
            	PushFollow(FOLLOW_boolean_expression_in_where_clause3623);
            	boolean_expression484 = boolean_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression484.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 131, where_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "where_clause"

    public class boolean_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "boolean_expression"
    // G:\\downloads\\antlr\\cs.g:515:1: boolean_expression : expression ;
    public csParser.boolean_expression_return boolean_expression() // throws RecognitionException [1]
    {   
        csParser.boolean_expression_return retval = new csParser.boolean_expression_return();
        retval.Start = input.LT(1);
        int boolean_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression485 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 132) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:515:19: ( expression )
            // G:\\downloads\\antlr\\cs.g:516:2: expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_boolean_expression3631);
            	expression485 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression485.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 132, boolean_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "boolean_expression"

    public class global_attributes_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "global_attributes"
    // G:\\downloads\\antlr\\cs.g:521:1: global_attributes : ( global_attribute )+ ;
    public csParser.global_attributes_return global_attributes() // throws RecognitionException [1]
    {   
        csParser.global_attributes_return retval = new csParser.global_attributes_return();
        retval.Start = input.LT(1);
        int global_attributes_StartIndex = input.Index();
        object root_0 = null;

        csParser.global_attribute_return global_attribute486 = default(csParser.global_attribute_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 133) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:521:18: ( ( global_attribute )+ )
            // G:\\downloads\\antlr\\cs.g:522:2: ( global_attribute )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:522:2: ( global_attribute )+
            	int cnt134 = 0;
            	do 
            	{
            	    int alt134 = 2;
            	    int LA134_0 = input.LA(1);

            	    if ( (LA134_0 == 86) )
            	    {
            	        int LA134_2 = input.LA(2);

            	        if ( ((LA134_2 >= 146 && LA134_2 <= 147)) )
            	        {
            	            int LA134_3 = input.LA(3);

            	            if ( (LA134_3 == 90) )
            	            {
            	                alt134 = 1;
            	            }


            	        }


            	    }


            	    switch (alt134) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:522:2: global_attribute
            			    {
            			    	PushFollow(FOLLOW_global_attribute_in_global_attributes3643);
            			    	global_attribute486 = global_attribute();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attribute486.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt134 >= 1 ) goto loop134;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(134, input);
            		            throw eee;
            	    }
            	    cnt134++;
            	} while (true);

            	loop134:
            		;	// Stops C# compiler whinging that label 'loop134' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 133, global_attributes_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "global_attributes"

    public class global_attribute_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "global_attribute"
    // G:\\downloads\\antlr\\cs.g:523:1: global_attribute : '[' global_attribute_target_specifier attribute_list ( ',' )? ']' ;
    public csParser.global_attribute_return global_attribute() // throws RecognitionException [1]
    {   
        csParser.global_attribute_return retval = new csParser.global_attribute_return();
        retval.Start = input.LT(1);
        int global_attribute_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal487 = null;
        IToken char_literal490 = null;
        IToken char_literal491 = null;
        csParser.global_attribute_target_specifier_return global_attribute_target_specifier488 = default(csParser.global_attribute_target_specifier_return);

        csParser.attribute_list_return attribute_list489 = default(csParser.attribute_list_return);


        object char_literal487_tree=null;
        object char_literal490_tree=null;
        object char_literal491_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 134) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:523:17: ( '[' global_attribute_target_specifier attribute_list ( ',' )? ']' )
            // G:\\downloads\\antlr\\cs.g:524:2: '[' global_attribute_target_specifier attribute_list ( ',' )? ']'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal487=(IToken)Match(input,86,FOLLOW_86_in_global_attribute3653); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal487_tree = (object)adaptor.Create(char_literal487);
            		adaptor.AddChild(root_0, char_literal487_tree);
            	}
            	PushFollow(FOLLOW_global_attribute_target_specifier_in_global_attribute3657);
            	global_attribute_target_specifier488 = global_attribute_target_specifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attribute_target_specifier488.Tree);
            	PushFollow(FOLLOW_attribute_list_in_global_attribute3661);
            	attribute_list489 = attribute_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_list489.Tree);
            	// G:\\downloads\\antlr\\cs.g:524:61: ( ',' )?
            	int alt135 = 2;
            	int LA135_0 = input.LA(1);

            	if ( (LA135_0 == 89) )
            	{
            	    alt135 = 1;
            	}
            	switch (alt135) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:524:61: ','
            	        {
            	        	char_literal490=(IToken)Match(input,89,FOLLOW_89_in_global_attribute3665); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal490_tree = (object)adaptor.Create(char_literal490);
            	        		adaptor.AddChild(root_0, char_literal490_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal491=(IToken)Match(input,87,FOLLOW_87_in_global_attribute3670); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal491_tree = (object)adaptor.Create(char_literal491);
            		adaptor.AddChild(root_0, char_literal491_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 134, global_attribute_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "global_attribute"

    public class global_attribute_target_specifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "global_attribute_target_specifier"
    // G:\\downloads\\antlr\\cs.g:525:1: global_attribute_target_specifier : global_attribute_target ':' ;
    public csParser.global_attribute_target_specifier_return global_attribute_target_specifier() // throws RecognitionException [1]
    {   
        csParser.global_attribute_target_specifier_return retval = new csParser.global_attribute_target_specifier_return();
        retval.Start = input.LT(1);
        int global_attribute_target_specifier_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal493 = null;
        csParser.global_attribute_target_return global_attribute_target492 = default(csParser.global_attribute_target_return);


        object char_literal493_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 135) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:525:34: ( global_attribute_target ':' )
            // G:\\downloads\\antlr\\cs.g:526:2: global_attribute_target ':'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_global_attribute_target_in_global_attribute_target_specifier3679);
            	global_attribute_target492 = global_attribute_target();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, global_attribute_target492.Tree);
            	char_literal493=(IToken)Match(input,90,FOLLOW_90_in_global_attribute_target_specifier3683); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal493_tree = (object)adaptor.Create(char_literal493);
            		adaptor.AddChild(root_0, char_literal493_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 135, global_attribute_target_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "global_attribute_target_specifier"

    public class global_attribute_target_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "global_attribute_target"
    // G:\\downloads\\antlr\\cs.g:527:1: global_attribute_target : ( 'assembly' | 'module' );
    public csParser.global_attribute_target_return global_attribute_target() // throws RecognitionException [1]
    {   
        csParser.global_attribute_target_return retval = new csParser.global_attribute_target_return();
        retval.Start = input.LT(1);
        int global_attribute_target_StartIndex = input.Index();
        object root_0 = null;

        IToken set494 = null;

        object set494_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 136) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:527:24: ( 'assembly' | 'module' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set494 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 146 && input.LA(1) <= 147) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set494));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 136, global_attribute_target_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "global_attribute_target"

    public class attributes_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attributes"
    // G:\\downloads\\antlr\\cs.g:529:1: attributes : attribute_sections ;
    public csParser.attributes_return attributes() // throws RecognitionException [1]
    {   
        csParser.attributes_return retval = new csParser.attributes_return();
        retval.Start = input.LT(1);
        int attributes_StartIndex = input.Index();
        object root_0 = null;

        csParser.attribute_sections_return attribute_sections495 = default(csParser.attribute_sections_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 137) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:529:11: ( attribute_sections )
            // G:\\downloads\\antlr\\cs.g:530:2: attribute_sections
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_attribute_sections_in_attributes3705);
            	attribute_sections495 = attribute_sections();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_sections495.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 137, attributes_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attributes"

    public class attribute_sections_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute_sections"
    // G:\\downloads\\antlr\\cs.g:531:1: attribute_sections : ( attribute_section )+ ;
    public csParser.attribute_sections_return attribute_sections() // throws RecognitionException [1]
    {   
        csParser.attribute_sections_return retval = new csParser.attribute_sections_return();
        retval.Start = input.LT(1);
        int attribute_sections_StartIndex = input.Index();
        object root_0 = null;

        csParser.attribute_section_return attribute_section496 = default(csParser.attribute_section_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 138) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:531:19: ( ( attribute_section )+ )
            // G:\\downloads\\antlr\\cs.g:532:2: ( attribute_section )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:532:2: ( attribute_section )+
            	int cnt136 = 0;
            	do 
            	{
            	    int alt136 = 2;
            	    int LA136_0 = input.LA(1);

            	    if ( (LA136_0 == 86) )
            	    {
            	        alt136 = 1;
            	    }


            	    switch (alt136) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:532:2: attribute_section
            			    {
            			    	PushFollow(FOLLOW_attribute_section_in_attribute_sections3714);
            			    	attribute_section496 = attribute_section();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_section496.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt136 >= 1 ) goto loop136;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(136, input);
            		            throw eee;
            	    }
            	    cnt136++;
            	} while (true);

            	loop136:
            		;	// Stops C# compiler whinging that label 'loop136' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 138, attribute_sections_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute_sections"

    public class attribute_section_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute_section"
    // G:\\downloads\\antlr\\cs.g:533:1: attribute_section : '[' ( attribute_target_specifier )? attribute_list ( ',' )? ']' ;
    public csParser.attribute_section_return attribute_section() // throws RecognitionException [1]
    {   
        csParser.attribute_section_return retval = new csParser.attribute_section_return();
        retval.Start = input.LT(1);
        int attribute_section_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal497 = null;
        IToken char_literal500 = null;
        IToken char_literal501 = null;
        csParser.attribute_target_specifier_return attribute_target_specifier498 = default(csParser.attribute_target_specifier_return);

        csParser.attribute_list_return attribute_list499 = default(csParser.attribute_list_return);


        object char_literal497_tree=null;
        object char_literal500_tree=null;
        object char_literal501_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 139) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:533:18: ( '[' ( attribute_target_specifier )? attribute_list ( ',' )? ']' )
            // G:\\downloads\\antlr\\cs.g:534:2: '[' ( attribute_target_specifier )? attribute_list ( ',' )? ']'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal497=(IToken)Match(input,86,FOLLOW_86_in_attribute_section3724); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal497_tree = (object)adaptor.Create(char_literal497);
            		adaptor.AddChild(root_0, char_literal497_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:534:8: ( attribute_target_specifier )?
            	int alt137 = 2;
            	int LA137_0 = input.LA(1);

            	if ( (LA137_0 == 148 || (LA137_0 >= 150 && LA137_0 <= 152) || LA137_0 == 154) )
            	{
            	    int LA137_1 = input.LA(2);

            	    if ( (LA137_1 == 90) )
            	    {
            	        alt137 = 1;
            	    }
            	}
            	else if ( (LA137_0 == 149 || LA137_0 == 153) )
            	{
            	    alt137 = 1;
            	}
            	switch (alt137) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:534:8: attribute_target_specifier
            	        {
            	        	PushFollow(FOLLOW_attribute_target_specifier_in_attribute_section3728);
            	        	attribute_target_specifier498 = attribute_target_specifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_target_specifier498.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_attribute_list_in_attribute_section3733);
            	attribute_list499 = attribute_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_list499.Tree);
            	// G:\\downloads\\antlr\\cs.g:534:55: ( ',' )?
            	int alt138 = 2;
            	int LA138_0 = input.LA(1);

            	if ( (LA138_0 == 89) )
            	{
            	    alt138 = 1;
            	}
            	switch (alt138) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:534:55: ','
            	        {
            	        	char_literal500=(IToken)Match(input,89,FOLLOW_89_in_attribute_section3737); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal500_tree = (object)adaptor.Create(char_literal500);
            	        		adaptor.AddChild(root_0, char_literal500_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal501=(IToken)Match(input,87,FOLLOW_87_in_attribute_section3742); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal501_tree = (object)adaptor.Create(char_literal501);
            		adaptor.AddChild(root_0, char_literal501_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 139, attribute_section_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute_section"

    public class attribute_target_specifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute_target_specifier"
    // G:\\downloads\\antlr\\cs.g:535:1: attribute_target_specifier : attribute_target ':' ;
    public csParser.attribute_target_specifier_return attribute_target_specifier() // throws RecognitionException [1]
    {   
        csParser.attribute_target_specifier_return retval = new csParser.attribute_target_specifier_return();
        retval.Start = input.LT(1);
        int attribute_target_specifier_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal503 = null;
        csParser.attribute_target_return attribute_target502 = default(csParser.attribute_target_return);


        object char_literal503_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 140) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:535:27: ( attribute_target ':' )
            // G:\\downloads\\antlr\\cs.g:536:2: attribute_target ':'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_attribute_target_in_attribute_target_specifier3751);
            	attribute_target502 = attribute_target();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_target502.Tree);
            	char_literal503=(IToken)Match(input,90,FOLLOW_90_in_attribute_target_specifier3755); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal503_tree = (object)adaptor.Create(char_literal503);
            		adaptor.AddChild(root_0, char_literal503_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 140, attribute_target_specifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute_target_specifier"

    public class attribute_target_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute_target"
    // G:\\downloads\\antlr\\cs.g:537:1: attribute_target : ( 'field' | 'event' | 'method' | 'param' | 'property' | 'return' | 'type' );
    public csParser.attribute_target_return attribute_target() // throws RecognitionException [1]
    {   
        csParser.attribute_target_return retval = new csParser.attribute_target_return();
        retval.Start = input.LT(1);
        int attribute_target_StartIndex = input.Index();
        object root_0 = null;

        IToken set504 = null;

        object set504_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 141) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:537:17: ( 'field' | 'event' | 'method' | 'param' | 'property' | 'return' | 'type' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set504 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 148 && input.LA(1) <= 154) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set504));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 141, attribute_target_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute_target"

    public class attribute_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute_list"
    // G:\\downloads\\antlr\\cs.g:539:1: attribute_list : attribute ( ',' attribute )* ;
    public csParser.attribute_list_return attribute_list() // throws RecognitionException [1]
    {   
        csParser.attribute_list_return retval = new csParser.attribute_list_return();
        retval.Start = input.LT(1);
        int attribute_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal506 = null;
        csParser.attribute_return attribute505 = default(csParser.attribute_return);

        csParser.attribute_return attribute507 = default(csParser.attribute_return);


        object char_literal506_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 142) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:539:15: ( attribute ( ',' attribute )* )
            // G:\\downloads\\antlr\\cs.g:540:2: attribute ( ',' attribute )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_attribute_in_attribute_list3797);
            	attribute505 = attribute();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute505.Tree);
            	// G:\\downloads\\antlr\\cs.g:540:12: ( ',' attribute )*
            	do 
            	{
            	    int alt139 = 2;
            	    int LA139_0 = input.LA(1);

            	    if ( (LA139_0 == 89) )
            	    {
            	        int LA139_1 = input.LA(2);

            	        if ( (LA139_1 == IDENTIFIER || LA139_1 == 65 || (LA139_1 >= 132 && LA139_1 <= 133) || (LA139_1 >= 135 && LA139_1 <= 148) || (LA139_1 >= 150 && LA139_1 <= 152) || LA139_1 == 154 || (LA139_1 >= 157 && LA139_1 <= 159) || LA139_1 == 170 || (LA139_1 >= 177 && LA139_1 <= 178) || LA139_1 == 195 || LA139_1 == 202) )
            	        {
            	            alt139 = 1;
            	        }


            	    }


            	    switch (alt139) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:540:13: ',' attribute
            			    {
            			    	char_literal506=(IToken)Match(input,89,FOLLOW_89_in_attribute_list3800); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal506_tree = (object)adaptor.Create(char_literal506);
            			    		adaptor.AddChild(root_0, char_literal506_tree);
            			    	}
            			    	PushFollow(FOLLOW_attribute_in_attribute_list3802);
            			    	attribute507 = attribute();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute507.Tree);

            			    }
            			    break;

            			default:
            			    goto loop139;
            	    }
            	} while (true);

            	loop139:
            		;	// Stops C# compiler whining that label 'loop139' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 142, attribute_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute_list"

    public class attribute_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute"
    // G:\\downloads\\antlr\\cs.g:541:1: attribute : type_name ( attribute_arguments )? ;
    public csParser.attribute_return attribute() // throws RecognitionException [1]
    {   
        csParser.attribute_return retval = new csParser.attribute_return();
        retval.Start = input.LT(1);
        int attribute_StartIndex = input.Index();
        object root_0 = null;

        csParser.type_name_return type_name508 = default(csParser.type_name_return);

        csParser.attribute_arguments_return attribute_arguments509 = default(csParser.attribute_arguments_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 143) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:541:10: ( type_name ( attribute_arguments )? )
            // G:\\downloads\\antlr\\cs.g:542:2: type_name ( attribute_arguments )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_name_in_attribute3814);
            	type_name508 = type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name508.Tree);
            	// G:\\downloads\\antlr\\cs.g:542:14: ( attribute_arguments )?
            	int alt140 = 2;
            	int LA140_0 = input.LA(1);

            	if ( (LA140_0 == 88) )
            	{
            	    alt140 = 1;
            	}
            	switch (alt140) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:542:14: attribute_arguments
            	        {
            	        	PushFollow(FOLLOW_attribute_arguments_in_attribute3818);
            	        	attribute_arguments509 = attribute_arguments();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_arguments509.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 143, attribute_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute"

    public class attribute_arguments_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute_arguments"
    // G:\\downloads\\antlr\\cs.g:544:1: attribute_arguments : '(' ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' ) ;
    public csParser.attribute_arguments_return attribute_arguments() // throws RecognitionException [1]
    {   
        csParser.attribute_arguments_return retval = new csParser.attribute_arguments_return();
        retval.Start = input.LT(1);
        int attribute_arguments_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal510 = null;
        IToken char_literal511 = null;
        IToken char_literal514 = null;
        IToken char_literal516 = null;
        csParser.positional_argument_return positional_argument512 = default(csParser.positional_argument_return);

        csParser.named_argument_return named_argument513 = default(csParser.named_argument_return);

        csParser.positional_argument_return positional_argument515 = default(csParser.positional_argument_return);


        object char_literal510_tree=null;
        object char_literal511_tree=null;
        object char_literal514_tree=null;
        object char_literal516_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 144) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:544:20: ( '(' ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' ) )
            // G:\\downloads\\antlr\\cs.g:545:2: '(' ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal510=(IToken)Match(input,88,FOLLOW_88_in_attribute_arguments3829); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal510_tree = (object)adaptor.Create(char_literal510);
            		adaptor.AddChild(root_0, char_literal510_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:545:8: ( ')' | ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')' )
            	int alt142 = 2;
            	int LA142_0 = input.LA(1);

            	if ( (LA142_0 == RPAREN) )
            	{
            	    alt142 = 1;
            	}
            	else if ( ((LA142_0 >= IDENTIFIER && LA142_0 <= NULL) || LA142_0 == MINUS || LA142_0 == 65 || LA142_0 == 68 || LA142_0 == 83 || LA142_0 == 85 || LA142_0 == 88 || (LA142_0 >= 93 && LA142_0 <= 98) || LA142_0 == 100 || (LA142_0 >= 102 && LA142_0 <= 106) || LA142_0 == 117 || (LA142_0 >= 132 && LA142_0 <= 133) || (LA142_0 >= 135 && LA142_0 <= 148) || (LA142_0 >= 150 && LA142_0 <= 152) || LA142_0 == 154 || (LA142_0 >= 157 && LA142_0 <= 168) || LA142_0 == 170 || (LA142_0 >= 177 && LA142_0 <= 178) || (LA142_0 >= 195 && LA142_0 <= 202)) )
            	{
            	    alt142 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d142s0 =
            	        new NoViableAltException("", 142, 0, input);

            	    throw nvae_d142s0;
            	}
            	switch (alt142) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:545:9: ')'
            	        {
            	        	char_literal511=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_attribute_arguments3834); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal511_tree = (object)adaptor.Create(char_literal511);
            	        		adaptor.AddChild(root_0, char_literal511_tree);
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:546:8: ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* ) ')'
            	        {
            	        	// G:\\downloads\\antlr\\cs.g:546:8: ( positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )* )
            	        	// G:\\downloads\\antlr\\cs.g:546:9: positional_argument ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )*
            	        	{
            	        		PushFollow(FOLLOW_positional_argument_in_attribute_arguments3854);
            	        		positional_argument512 = positional_argument();
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument512.Tree);
            	        		// G:\\downloads\\antlr\\cs.g:546:31: ( ( ',' identifier '=' )=> named_argument | ',' positional_argument )*
            	        		do 
            	        		{
            	        		    int alt141 = 3;
            	        		    int LA141_0 = input.LA(1);

            	        		    if ( (LA141_0 == IDENTIFIER || LA141_0 == 65 || (LA141_0 >= 132 && LA141_0 <= 133) || (LA141_0 >= 135 && LA141_0 <= 148) || (LA141_0 >= 150 && LA141_0 <= 152) || LA141_0 == 154 || (LA141_0 >= 157 && LA141_0 <= 159) || LA141_0 == 170 || (LA141_0 >= 177 && LA141_0 <= 178) || LA141_0 == 195 || LA141_0 == 202) && (synpred24_cs()) )
            	        		    {
            	        		        alt141 = 1;
            	        		    }
            	        		    else if ( (LA141_0 == 89) )
            	        		    {
            	        		        alt141 = 2;
            	        		    }


            	        		    switch (alt141) 
            	        			{
            	        				case 1 :
            	        				    // G:\\downloads\\antlr\\cs.g:546:32: ( ',' identifier '=' )=> named_argument
            	        				    {
            	        				    	PushFollow(FOLLOW_named_argument_in_attribute_arguments3873);
            	        				    	named_argument513 = named_argument();
            	        				    	state.followingStackPointer--;
            	        				    	if (state.failed) return retval;
            	        				    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, named_argument513.Tree);

            	        				    }
            	        				    break;
            	        				case 2 :
            	        				    // G:\\downloads\\antlr\\cs.g:547:15: ',' positional_argument
            	        				    {
            	        				    	char_literal514=(IToken)Match(input,89,FOLLOW_89_in_attribute_arguments3889); if (state.failed) return retval;
            	        				    	if ( state.backtracking == 0 )
            	        				    	{char_literal514_tree = (object)adaptor.Create(char_literal514);
            	        				    		adaptor.AddChild(root_0, char_literal514_tree);
            	        				    	}
            	        				    	PushFollow(FOLLOW_positional_argument_in_attribute_arguments3891);
            	        				    	positional_argument515 = positional_argument();
            	        				    	state.followingStackPointer--;
            	        				    	if (state.failed) return retval;
            	        				    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument515.Tree);

            	        				    }
            	        				    break;

            	        				default:
            	        				    goto loop141;
            	        		    }
            	        		} while (true);

            	        		loop141:
            	        			;	// Stops C# compiler whining that label 'loop141' has no statements


            	        	}

            	        	char_literal516=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_attribute_arguments3902); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal516_tree = (object)adaptor.Create(char_literal516);
            	        		adaptor.AddChild(root_0, char_literal516_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 144, attribute_arguments_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute_arguments"

    public class positional_argument_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "positional_argument_list"
    // G:\\downloads\\antlr\\cs.g:550:1: positional_argument_list : positional_argument ( ',' positional_argument )* ;
    public csParser.positional_argument_list_return positional_argument_list() // throws RecognitionException [1]
    {   
        csParser.positional_argument_list_return retval = new csParser.positional_argument_list_return();
        retval.Start = input.LT(1);
        int positional_argument_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal518 = null;
        csParser.positional_argument_return positional_argument517 = default(csParser.positional_argument_return);

        csParser.positional_argument_return positional_argument519 = default(csParser.positional_argument_return);


        object char_literal518_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 145) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:550:25: ( positional_argument ( ',' positional_argument )* )
            // G:\\downloads\\antlr\\cs.g:551:2: positional_argument ( ',' positional_argument )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_positional_argument_in_positional_argument_list3916);
            	positional_argument517 = positional_argument();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument517.Tree);
            	// G:\\downloads\\antlr\\cs.g:551:22: ( ',' positional_argument )*
            	do 
            	{
            	    int alt143 = 2;
            	    int LA143_0 = input.LA(1);

            	    if ( (LA143_0 == 89) )
            	    {
            	        alt143 = 1;
            	    }


            	    switch (alt143) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:551:23: ',' positional_argument
            			    {
            			    	char_literal518=(IToken)Match(input,89,FOLLOW_89_in_positional_argument_list3919); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal518_tree = (object)adaptor.Create(char_literal518);
            			    		adaptor.AddChild(root_0, char_literal518_tree);
            			    	}
            			    	PushFollow(FOLLOW_positional_argument_in_positional_argument_list3921);
            			    	positional_argument519 = positional_argument();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, positional_argument519.Tree);

            			    }
            			    break;

            			default:
            			    goto loop143;
            	    }
            	} while (true);

            	loop143:
            		;	// Stops C# compiler whining that label 'loop143' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 145, positional_argument_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "positional_argument_list"

    public class positional_argument_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "positional_argument"
    // G:\\downloads\\antlr\\cs.g:552:1: positional_argument : attribute_argument_expression ;
    public csParser.positional_argument_return positional_argument() // throws RecognitionException [1]
    {   
        csParser.positional_argument_return retval = new csParser.positional_argument_return();
        retval.Start = input.LT(1);
        int positional_argument_StartIndex = input.Index();
        object root_0 = null;

        csParser.attribute_argument_expression_return attribute_argument_expression520 = default(csParser.attribute_argument_expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 146) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:552:20: ( attribute_argument_expression )
            // G:\\downloads\\antlr\\cs.g:553:2: attribute_argument_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_attribute_argument_expression_in_positional_argument3932);
            	attribute_argument_expression520 = attribute_argument_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_argument_expression520.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 146, positional_argument_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "positional_argument"

    public class named_argument_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "named_argument_list"
    // G:\\downloads\\antlr\\cs.g:554:1: named_argument_list : named_argument ( ',' named_argument )* ;
    public csParser.named_argument_list_return named_argument_list() // throws RecognitionException [1]
    {   
        csParser.named_argument_list_return retval = new csParser.named_argument_list_return();
        retval.Start = input.LT(1);
        int named_argument_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal522 = null;
        csParser.named_argument_return named_argument521 = default(csParser.named_argument_return);

        csParser.named_argument_return named_argument523 = default(csParser.named_argument_return);


        object char_literal522_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 147) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:554:20: ( named_argument ( ',' named_argument )* )
            // G:\\downloads\\antlr\\cs.g:555:2: named_argument ( ',' named_argument )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_named_argument_in_named_argument_list3941);
            	named_argument521 = named_argument();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, named_argument521.Tree);
            	// G:\\downloads\\antlr\\cs.g:555:17: ( ',' named_argument )*
            	do 
            	{
            	    int alt144 = 2;
            	    int LA144_0 = input.LA(1);

            	    if ( (LA144_0 == 89) )
            	    {
            	        alt144 = 1;
            	    }


            	    switch (alt144) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:555:18: ',' named_argument
            			    {
            			    	char_literal522=(IToken)Match(input,89,FOLLOW_89_in_named_argument_list3944); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal522_tree = (object)adaptor.Create(char_literal522);
            			    		adaptor.AddChild(root_0, char_literal522_tree);
            			    	}
            			    	PushFollow(FOLLOW_named_argument_in_named_argument_list3946);
            			    	named_argument523 = named_argument();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, named_argument523.Tree);

            			    }
            			    break;

            			default:
            			    goto loop144;
            	    }
            	} while (true);

            	loop144:
            		;	// Stops C# compiler whining that label 'loop144' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 147, named_argument_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "named_argument_list"

    public class named_argument_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "named_argument"
    // G:\\downloads\\antlr\\cs.g:556:1: named_argument : identifier '=' attribute_argument_expression ;
    public csParser.named_argument_return named_argument() // throws RecognitionException [1]
    {   
        csParser.named_argument_return retval = new csParser.named_argument_return();
        retval.Start = input.LT(1);
        int named_argument_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal525 = null;
        csParser.identifier_return identifier524 = default(csParser.identifier_return);

        csParser.attribute_argument_expression_return attribute_argument_expression526 = default(csParser.attribute_argument_expression_return);


        object char_literal525_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 148) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:556:15: ( identifier '=' attribute_argument_expression )
            // G:\\downloads\\antlr\\cs.g:557:2: identifier '=' attribute_argument_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_named_argument3957);
            	identifier524 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier524.Tree);
            	char_literal525=(IToken)Match(input,66,FOLLOW_66_in_named_argument3961); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal525_tree = (object)adaptor.Create(char_literal525);
            		adaptor.AddChild(root_0, char_literal525_tree);
            	}
            	PushFollow(FOLLOW_attribute_argument_expression_in_named_argument3965);
            	attribute_argument_expression526 = attribute_argument_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attribute_argument_expression526.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 148, named_argument_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "named_argument"

    public class attribute_argument_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "attribute_argument_expression"
    // G:\\downloads\\antlr\\cs.g:558:1: attribute_argument_expression : expression ;
    public csParser.attribute_argument_expression_return attribute_argument_expression() // throws RecognitionException [1]
    {   
        csParser.attribute_argument_expression_return retval = new csParser.attribute_argument_expression_return();
        retval.Start = input.LT(1);
        int attribute_argument_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression527 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 149) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:558:30: ( expression )
            // G:\\downloads\\antlr\\cs.g:559:2: expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_attribute_argument_expression3974);
            	expression527 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression527.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 149, attribute_argument_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "attribute_argument_expression"

    public class class_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "class_declaration"
    // G:\\downloads\\antlr\\cs.g:565:1: class_declaration : 'class' type_or_generic ( class_base )? ( type_parameter_constraints_clauses )? class_body ( ';' )? ;
    public csParser.class_declaration_return class_declaration() // throws RecognitionException [1]
    {   
        csParser.class_declaration_return retval = new csParser.class_declaration_return();
        retval.Start = input.LT(1);
        int class_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal528 = null;
        IToken char_literal533 = null;
        csParser.type_or_generic_return type_or_generic529 = default(csParser.type_or_generic_return);

        csParser.class_base_return class_base530 = default(csParser.class_base_return);

        csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses531 = default(csParser.type_parameter_constraints_clauses_return);

        csParser.class_body_return class_body532 = default(csParser.class_body_return);


        object string_literal528_tree=null;
        object char_literal533_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 150) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:565:18: ( 'class' type_or_generic ( class_base )? ( type_parameter_constraints_clauses )? class_body ( ';' )? )
            // G:\\downloads\\antlr\\cs.g:566:2: 'class' type_or_generic ( class_base )? ( type_parameter_constraints_clauses )? class_body ( ';' )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal528=(IToken)Match(input,155,FOLLOW_155_in_class_declaration3987); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal528_tree = (object)adaptor.Create(string_literal528);
            		adaptor.AddChild(root_0, string_literal528_tree);
            	}
            	PushFollow(FOLLOW_type_or_generic_in_class_declaration3990);
            	type_or_generic529 = type_or_generic();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic529.Tree);
            	// G:\\downloads\\antlr\\cs.g:566:29: ( class_base )?
            	int alt145 = 2;
            	int LA145_0 = input.LA(1);

            	if ( (LA145_0 == 90) )
            	{
            	    alt145 = 1;
            	}
            	switch (alt145) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:566:29: class_base
            	        {
            	        	PushFollow(FOLLOW_class_base_in_class_declaration3994);
            	        	class_base530 = class_base();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_base530.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:566:43: ( type_parameter_constraints_clauses )?
            	int alt146 = 2;
            	int LA146_0 = input.LA(1);

            	if ( (LA146_0 == 145) )
            	{
            	    alt146 = 1;
            	}
            	switch (alt146) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:566:43: type_parameter_constraints_clauses
            	        {
            	        	PushFollow(FOLLOW_type_parameter_constraints_clauses_in_class_declaration3999);
            	        	type_parameter_constraints_clauses531 = type_parameter_constraints_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses531.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_class_body_in_class_declaration4004);
            	class_body532 = class_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_body532.Tree);
            	// G:\\downloads\\antlr\\cs.g:566:94: ( ';' )?
            	int alt147 = 2;
            	int LA147_0 = input.LA(1);

            	if ( (LA147_0 == SEMI) )
            	{
            	    alt147 = 1;
            	}
            	switch (alt147) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:566:94: ';'
            	        {
            	        	char_literal533=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_class_declaration4008); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal533_tree = (object)adaptor.Create(char_literal533);
            	        		adaptor.AddChild(root_0, char_literal533_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 150, class_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "class_declaration"

    public class class_base_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "class_base"
    // G:\\downloads\\antlr\\cs.g:567:1: class_base : ':' interface_type_list ;
    public csParser.class_base_return class_base() // throws RecognitionException [1]
    {   
        csParser.class_base_return retval = new csParser.class_base_return();
        retval.Start = input.LT(1);
        int class_base_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal534 = null;
        csParser.interface_type_list_return interface_type_list535 = default(csParser.interface_type_list_return);


        object char_literal534_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 151) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:567:11: ( ':' interface_type_list )
            // G:\\downloads\\antlr\\cs.g:570:2: ':' interface_type_list
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal534=(IToken)Match(input,90,FOLLOW_90_in_class_base4021); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal534_tree = (object)adaptor.Create(char_literal534);
            		adaptor.AddChild(root_0, char_literal534_tree);
            	}
            	PushFollow(FOLLOW_interface_type_list_in_class_base4025);
            	interface_type_list535 = interface_type_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_type_list535.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 151, class_base_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "class_base"

    public class interface_type_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_type_list"
    // G:\\downloads\\antlr\\cs.g:572:1: interface_type_list : type ( ',' type )* ;
    public csParser.interface_type_list_return interface_type_list() // throws RecognitionException [1]
    {   
        csParser.interface_type_list_return retval = new csParser.interface_type_list_return();
        retval.Start = input.LT(1);
        int interface_type_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal537 = null;
        csParser.type_return type536 = default(csParser.type_return);

        csParser.type_return type538 = default(csParser.type_return);


        object char_literal537_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 152) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:572:20: ( type ( ',' type )* )
            // G:\\downloads\\antlr\\cs.g:573:2: type ( ',' type )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_in_interface_type_list4035);
            	type536 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type536.Tree);
            	// G:\\downloads\\antlr\\cs.g:573:7: ( ',' type )*
            	do 
            	{
            	    int alt148 = 2;
            	    int LA148_0 = input.LA(1);

            	    if ( (LA148_0 == 89) )
            	    {
            	        alt148 = 1;
            	    }


            	    switch (alt148) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:573:8: ',' type
            			    {
            			    	char_literal537=(IToken)Match(input,89,FOLLOW_89_in_interface_type_list4038); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal537_tree = (object)adaptor.Create(char_literal537);
            			    		adaptor.AddChild(root_0, char_literal537_tree);
            			    	}
            			    	PushFollow(FOLLOW_type_in_interface_type_list4042);
            			    	type538 = type();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type538.Tree);

            			    }
            			    break;

            			default:
            			    goto loop148;
            	    }
            	} while (true);

            	loop148:
            		;	// Stops C# compiler whining that label 'loop148' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 152, interface_type_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_type_list"

    public class class_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "class_body"
    // G:\\downloads\\antlr\\cs.g:575:1: class_body : '{' ( class_member_declarations )? '}' ;
    public csParser.class_body_return class_body() // throws RecognitionException [1]
    {   
        csParser.class_body_return retval = new csParser.class_body_return();
        retval.Start = input.LT(1);
        int class_body_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal539 = null;
        IToken char_literal541 = null;
        csParser.class_member_declarations_return class_member_declarations540 = default(csParser.class_member_declarations_return);


        object char_literal539_tree=null;
        object char_literal541_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 153) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:575:11: ( '{' ( class_member_declarations )? '}' )
            // G:\\downloads\\antlr\\cs.g:576:2: '{' ( class_member_declarations )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal539=(IToken)Match(input,62,FOLLOW_62_in_class_body4053); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal539_tree = (object)adaptor.Create(char_literal539);
            		adaptor.AddChild(root_0, char_literal539_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:576:8: ( class_member_declarations )?
            	int alt149 = 2;
            	int LA149_0 = input.LA(1);

            	if ( (LA149_0 == IDENTIFIER || LA149_0 == ENUM || (LA149_0 >= 64 && LA149_0 <= 65) || (LA149_0 >= 67 && LA149_0 <= 82) || LA149_0 == 86 || LA149_0 == 97 || LA149_0 == 106 || (LA149_0 >= 132 && LA149_0 <= 133) || (LA149_0 >= 135 && LA149_0 <= 152) || (LA149_0 >= 154 && LA149_0 <= 155) || (LA149_0 >= 157 && LA149_0 <= 170) || LA149_0 == 172 || (LA149_0 >= 174 && LA149_0 <= 175) || (LA149_0 >= 177 && LA149_0 <= 178) || (LA149_0 >= 195 && LA149_0 <= 202)) )
            	{
            	    alt149 = 1;
            	}
            	switch (alt149) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:576:8: class_member_declarations
            	        {
            	        	PushFollow(FOLLOW_class_member_declarations_in_class_body4057);
            	        	class_member_declarations540 = class_member_declarations();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_member_declarations540.Tree);

            	        }
            	        break;

            	}

            	char_literal541=(IToken)Match(input,63,FOLLOW_63_in_class_body4062); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal541_tree = (object)adaptor.Create(char_literal541);
            		adaptor.AddChild(root_0, char_literal541_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 153, class_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "class_body"

    public class class_member_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "class_member_declarations"
    // G:\\downloads\\antlr\\cs.g:577:1: class_member_declarations : ( class_member_declaration )+ ;
    public csParser.class_member_declarations_return class_member_declarations() // throws RecognitionException [1]
    {   
        csParser.class_member_declarations_return retval = new csParser.class_member_declarations_return();
        retval.Start = input.LT(1);
        int class_member_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.class_member_declaration_return class_member_declaration542 = default(csParser.class_member_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 154) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:577:26: ( ( class_member_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:578:2: ( class_member_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:578:2: ( class_member_declaration )+
            	int cnt150 = 0;
            	do 
            	{
            	    int alt150 = 2;
            	    int LA150_0 = input.LA(1);

            	    if ( (LA150_0 == IDENTIFIER || LA150_0 == ENUM || (LA150_0 >= 64 && LA150_0 <= 65) || (LA150_0 >= 67 && LA150_0 <= 82) || LA150_0 == 86 || LA150_0 == 97 || LA150_0 == 106 || (LA150_0 >= 132 && LA150_0 <= 133) || (LA150_0 >= 135 && LA150_0 <= 152) || (LA150_0 >= 154 && LA150_0 <= 155) || (LA150_0 >= 157 && LA150_0 <= 170) || LA150_0 == 172 || (LA150_0 >= 174 && LA150_0 <= 175) || (LA150_0 >= 177 && LA150_0 <= 178) || (LA150_0 >= 195 && LA150_0 <= 202)) )
            	    {
            	        alt150 = 1;
            	    }


            	    switch (alt150) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:578:2: class_member_declaration
            			    {
            			    	PushFollow(FOLLOW_class_member_declaration_in_class_member_declarations4070);
            			    	class_member_declaration542 = class_member_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_member_declaration542.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt150 >= 1 ) goto loop150;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(150, input);
            		            throw eee;
            	    }
            	    cnt150++;
            	} while (true);

            	loop150:
            		;	// Stops C# compiler whinging that label 'loop150' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 154, class_member_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "class_member_declarations"

    public class constant_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constant_declaration"
    // G:\\downloads\\antlr\\cs.g:581:1: constant_declaration : 'const' type constant_declarators ';' ;
    public csParser.constant_declaration_return constant_declaration() // throws RecognitionException [1]
    {   
        csParser.constant_declaration_return retval = new csParser.constant_declaration_return();
        retval.Start = input.LT(1);
        int constant_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal543 = null;
        IToken char_literal546 = null;
        csParser.type_return type544 = default(csParser.type_return);

        csParser.constant_declarators_return constant_declarators545 = default(csParser.constant_declarators_return);


        object string_literal543_tree=null;
        object char_literal546_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 155) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:581:21: ( 'const' type constant_declarators ';' )
            // G:\\downloads\\antlr\\cs.g:582:2: 'const' type constant_declarators ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal543=(IToken)Match(input,81,FOLLOW_81_in_constant_declaration4081); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal543_tree = (object)adaptor.Create(string_literal543);
            		adaptor.AddChild(root_0, string_literal543_tree);
            	}
            	PushFollow(FOLLOW_type_in_constant_declaration4085);
            	type544 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type544.Tree);
            	PushFollow(FOLLOW_constant_declarators_in_constant_declaration4089);
            	constant_declarators545 = constant_declarators();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators545.Tree);
            	char_literal546=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_constant_declaration4093); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal546_tree = (object)adaptor.Create(char_literal546);
            		adaptor.AddChild(root_0, char_literal546_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 155, constant_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constant_declaration"

    public class constant_declarators_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constant_declarators"
    // G:\\downloads\\antlr\\cs.g:583:1: constant_declarators : constant_declarator ( ',' constant_declarator )* ;
    public csParser.constant_declarators_return constant_declarators() // throws RecognitionException [1]
    {   
        csParser.constant_declarators_return retval = new csParser.constant_declarators_return();
        retval.Start = input.LT(1);
        int constant_declarators_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal548 = null;
        csParser.constant_declarator_return constant_declarator547 = default(csParser.constant_declarator_return);

        csParser.constant_declarator_return constant_declarator549 = default(csParser.constant_declarator_return);


        object char_literal548_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 156) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:583:21: ( constant_declarator ( ',' constant_declarator )* )
            // G:\\downloads\\antlr\\cs.g:584:2: constant_declarator ( ',' constant_declarator )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_constant_declarator_in_constant_declarators4101);
            	constant_declarator547 = constant_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarator547.Tree);
            	// G:\\downloads\\antlr\\cs.g:584:22: ( ',' constant_declarator )*
            	do 
            	{
            	    int alt151 = 2;
            	    int LA151_0 = input.LA(1);

            	    if ( (LA151_0 == 89) )
            	    {
            	        alt151 = 1;
            	    }


            	    switch (alt151) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:584:23: ',' constant_declarator
            			    {
            			    	char_literal548=(IToken)Match(input,89,FOLLOW_89_in_constant_declarators4104); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal548_tree = (object)adaptor.Create(char_literal548);
            			    		adaptor.AddChild(root_0, char_literal548_tree);
            			    	}
            			    	PushFollow(FOLLOW_constant_declarator_in_constant_declarators4106);
            			    	constant_declarator549 = constant_declarator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarator549.Tree);

            			    }
            			    break;

            			default:
            			    goto loop151;
            	    }
            	} while (true);

            	loop151:
            		;	// Stops C# compiler whining that label 'loop151' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 156, constant_declarators_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constant_declarators"

    public class constant_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constant_declarator"
    // G:\\downloads\\antlr\\cs.g:585:1: constant_declarator : identifier ( '=' constant_expression )? ;
    public csParser.constant_declarator_return constant_declarator() // throws RecognitionException [1]
    {   
        csParser.constant_declarator_return retval = new csParser.constant_declarator_return();
        retval.Start = input.LT(1);
        int constant_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal551 = null;
        csParser.identifier_return identifier550 = default(csParser.identifier_return);

        csParser.constant_expression_return constant_expression552 = default(csParser.constant_expression_return);


        object char_literal551_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 157) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:585:20: ( identifier ( '=' constant_expression )? )
            // G:\\downloads\\antlr\\cs.g:586:2: identifier ( '=' constant_expression )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_constant_declarator4116);
            	identifier550 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier550.Tree);
            	// G:\\downloads\\antlr\\cs.g:586:15: ( '=' constant_expression )?
            	int alt152 = 2;
            	int LA152_0 = input.LA(1);

            	if ( (LA152_0 == 66) )
            	{
            	    alt152 = 1;
            	}
            	switch (alt152) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:586:16: '=' constant_expression
            	        {
            	        	char_literal551=(IToken)Match(input,66,FOLLOW_66_in_constant_declarator4121); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal551_tree = (object)adaptor.Create(char_literal551);
            	        		adaptor.AddChild(root_0, char_literal551_tree);
            	        	}
            	        	PushFollow(FOLLOW_constant_expression_in_constant_declarator4125);
            	        	constant_expression552 = constant_expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_expression552.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 157, constant_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constant_declarator"

    public class constant_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constant_expression"
    // G:\\downloads\\antlr\\cs.g:587:1: constant_expression : expression ;
    public csParser.constant_expression_return constant_expression() // throws RecognitionException [1]
    {   
        csParser.constant_expression_return retval = new csParser.constant_expression_return();
        retval.Start = input.LT(1);
        int constant_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression553 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 158) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:587:20: ( expression )
            // G:\\downloads\\antlr\\cs.g:588:2: expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_constant_expression4135);
            	expression553 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression553.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 158, constant_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constant_expression"

    public class field_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "field_declaration"
    // G:\\downloads\\antlr\\cs.g:591:1: field_declaration : variable_declarators ';' ;
    public csParser.field_declaration_return field_declaration() // throws RecognitionException [1]
    {   
        csParser.field_declaration_return retval = new csParser.field_declaration_return();
        retval.Start = input.LT(1);
        int field_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal555 = null;
        csParser.variable_declarators_return variable_declarators554 = default(csParser.variable_declarators_return);


        object char_literal555_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 159) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:591:18: ( variable_declarators ';' )
            // G:\\downloads\\antlr\\cs.g:592:2: variable_declarators ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_variable_declarators_in_field_declaration4144);
            	variable_declarators554 = variable_declarators();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarators554.Tree);
            	char_literal555=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_field_declaration4148); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal555_tree = (object)adaptor.Create(char_literal555);
            		adaptor.AddChild(root_0, char_literal555_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 159, field_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "field_declaration"

    public class variable_declarators_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variable_declarators"
    // G:\\downloads\\antlr\\cs.g:593:1: variable_declarators : variable_declarator ( ',' variable_declarator )* ;
    public csParser.variable_declarators_return variable_declarators() // throws RecognitionException [1]
    {   
        csParser.variable_declarators_return retval = new csParser.variable_declarators_return();
        retval.Start = input.LT(1);
        int variable_declarators_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal557 = null;
        csParser.variable_declarator_return variable_declarator556 = default(csParser.variable_declarator_return);

        csParser.variable_declarator_return variable_declarator558 = default(csParser.variable_declarator_return);


        object char_literal557_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 160) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:593:21: ( variable_declarator ( ',' variable_declarator )* )
            // G:\\downloads\\antlr\\cs.g:594:2: variable_declarator ( ',' variable_declarator )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_variable_declarator_in_variable_declarators4156);
            	variable_declarator556 = variable_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarator556.Tree);
            	// G:\\downloads\\antlr\\cs.g:594:22: ( ',' variable_declarator )*
            	do 
            	{
            	    int alt153 = 2;
            	    int LA153_0 = input.LA(1);

            	    if ( (LA153_0 == 89) )
            	    {
            	        alt153 = 1;
            	    }


            	    switch (alt153) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:594:23: ',' variable_declarator
            			    {
            			    	char_literal557=(IToken)Match(input,89,FOLLOW_89_in_variable_declarators4159); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal557_tree = (object)adaptor.Create(char_literal557);
            			    		adaptor.AddChild(root_0, char_literal557_tree);
            			    	}
            			    	PushFollow(FOLLOW_variable_declarator_in_variable_declarators4163);
            			    	variable_declarator558 = variable_declarator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarator558.Tree);

            			    }
            			    break;

            			default:
            			    goto loop153;
            	    }
            	} while (true);

            	loop153:
            		;	// Stops C# compiler whining that label 'loop153' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 160, variable_declarators_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variable_declarators"

    public class variable_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variable_declarator"
    // G:\\downloads\\antlr\\cs.g:595:1: variable_declarator : type_name ( '=' variable_initializer )? ;
    public csParser.variable_declarator_return variable_declarator() // throws RecognitionException [1]
    {   
        csParser.variable_declarator_return retval = new csParser.variable_declarator_return();
        retval.Start = input.LT(1);
        int variable_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal560 = null;
        csParser.type_name_return type_name559 = default(csParser.type_name_return);

        csParser.variable_initializer_return variable_initializer561 = default(csParser.variable_initializer_return);


        object char_literal560_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 161) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:595:20: ( type_name ( '=' variable_initializer )? )
            // G:\\downloads\\antlr\\cs.g:596:2: type_name ( '=' variable_initializer )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_name_in_variable_declarator4173);
            	type_name559 = type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name559.Tree);
            	// G:\\downloads\\antlr\\cs.g:596:12: ( '=' variable_initializer )?
            	int alt154 = 2;
            	int LA154_0 = input.LA(1);

            	if ( (LA154_0 == 66) )
            	{
            	    alt154 = 1;
            	}
            	switch (alt154) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:596:13: '=' variable_initializer
            	        {
            	        	char_literal560=(IToken)Match(input,66,FOLLOW_66_in_variable_declarator4176); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal560_tree = (object)adaptor.Create(char_literal560);
            	        		adaptor.AddChild(root_0, char_literal560_tree);
            	        	}
            	        	PushFollow(FOLLOW_variable_initializer_in_variable_declarator4180);
            	        	variable_initializer561 = variable_initializer();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_initializer561.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 161, variable_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variable_declarator"

    public class method_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "method_declaration"
    // G:\\downloads\\antlr\\cs.g:599:1: method_declaration : method_header method_body ;
    public csParser.method_declaration_return method_declaration() // throws RecognitionException [1]
    {   
        csParser.method_declaration_return retval = new csParser.method_declaration_return();
        retval.Start = input.LT(1);
        int method_declaration_StartIndex = input.Index();
        object root_0 = null;

        csParser.method_header_return method_header562 = default(csParser.method_header_return);

        csParser.method_body_return method_body563 = default(csParser.method_body_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 162) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:599:19: ( method_header method_body )
            // G:\\downloads\\antlr\\cs.g:600:2: method_header method_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_method_header_in_method_declaration4194);
            	method_header562 = method_header();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_header562.Tree);
            	PushFollow(FOLLOW_method_body_in_method_declaration4198);
            	method_body563 = method_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_body563.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 162, method_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "method_declaration"

    public class method_header_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "method_header"
    // G:\\downloads\\antlr\\cs.g:601:1: method_header : member_name '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ;
    public csParser.method_header_return method_header() // throws RecognitionException [1]
    {   
        csParser.method_header_return retval = new csParser.method_header_return();
        retval.Start = input.LT(1);
        int method_header_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal565 = null;
        IToken char_literal567 = null;
        csParser.member_name_return member_name564 = default(csParser.member_name_return);

        csParser.formal_parameter_list_return formal_parameter_list566 = default(csParser.formal_parameter_list_return);

        csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses568 = default(csParser.type_parameter_constraints_clauses_return);


        object char_literal565_tree=null;
        object char_literal567_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 163) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:601:14: ( member_name '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? )
            // G:\\downloads\\antlr\\cs.g:602:2: member_name '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_member_name_in_method_header4206);
            	member_name564 = member_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_name564.Tree);
            	char_literal565=(IToken)Match(input,88,FOLLOW_88_in_method_header4209); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal565_tree = (object)adaptor.Create(char_literal565);
            		adaptor.AddChild(root_0, char_literal565_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:602:21: ( formal_parameter_list )?
            	int alt155 = 2;
            	int LA155_0 = input.LA(1);

            	if ( (LA155_0 == IDENTIFIER || LA155_0 == 65 || (LA155_0 >= 82 && LA155_0 <= 83) || LA155_0 == 86 || (LA155_0 >= 91 && LA155_0 <= 92) || (LA155_0 >= 132 && LA155_0 <= 133) || (LA155_0 >= 135 && LA155_0 <= 148) || (LA155_0 >= 150 && LA155_0 <= 152) || LA155_0 == 154 || (LA155_0 >= 157 && LA155_0 <= 168) || (LA155_0 >= 170 && LA155_0 <= 171) || (LA155_0 >= 177 && LA155_0 <= 178) || (LA155_0 >= 195 && LA155_0 <= 202)) )
            	{
            	    alt155 = 1;
            	}
            	switch (alt155) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:602:21: formal_parameter_list
            	        {
            	        	PushFollow(FOLLOW_formal_parameter_list_in_method_header4213);
            	        	formal_parameter_list566 = formal_parameter_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list566.Tree);

            	        }
            	        break;

            	}

            	char_literal567=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_method_header4218); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal567_tree = (object)adaptor.Create(char_literal567);
            		adaptor.AddChild(root_0, char_literal567_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:602:52: ( type_parameter_constraints_clauses )?
            	int alt156 = 2;
            	int LA156_0 = input.LA(1);

            	if ( (LA156_0 == 145) )
            	{
            	    alt156 = 1;
            	}
            	switch (alt156) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:602:52: type_parameter_constraints_clauses
            	        {
            	        	PushFollow(FOLLOW_type_parameter_constraints_clauses_in_method_header4222);
            	        	type_parameter_constraints_clauses568 = type_parameter_constraints_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses568.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 163, method_header_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "method_header"

    public class method_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "method_body"
    // G:\\downloads\\antlr\\cs.g:603:1: method_body : block ;
    public csParser.method_body_return method_body() // throws RecognitionException [1]
    {   
        csParser.method_body_return retval = new csParser.method_body_return();
        retval.Start = input.LT(1);
        int method_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.block_return block569 = default(csParser.block_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 164) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:603:12: ( block )
            // G:\\downloads\\antlr\\cs.g:604:2: block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_block_in_method_body4231);
            	block569 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block569.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 164, method_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "method_body"

    public class member_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "member_name"
    // G:\\downloads\\antlr\\cs.g:605:1: member_name : qid ;
    public csParser.member_name_return member_name() // throws RecognitionException [1]
    {   
        csParser.member_name_return retval = new csParser.member_name_return();
        retval.Start = input.LT(1);
        int member_name_StartIndex = input.Index();
        object root_0 = null;

        csParser.qid_return qid570 = default(csParser.qid_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 165) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:605:12: ( qid )
            // G:\\downloads\\antlr\\cs.g:606:2: qid
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_qid_in_member_name4239);
            	qid570 = qid();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, qid570.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 165, member_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "member_name"

    public class property_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "property_declaration"
    // G:\\downloads\\antlr\\cs.g:609:1: property_declaration : member_name '{' accessor_declarations '}' ;
    public csParser.property_declaration_return property_declaration() // throws RecognitionException [1]
    {   
        csParser.property_declaration_return retval = new csParser.property_declaration_return();
        retval.Start = input.LT(1);
        int property_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal572 = null;
        IToken char_literal574 = null;
        csParser.member_name_return member_name571 = default(csParser.member_name_return);

        csParser.accessor_declarations_return accessor_declarations573 = default(csParser.accessor_declarations_return);


        object char_literal572_tree=null;
        object char_literal574_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 166) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:609:21: ( member_name '{' accessor_declarations '}' )
            // G:\\downloads\\antlr\\cs.g:610:2: member_name '{' accessor_declarations '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_member_name_in_property_declaration4251);
            	member_name571 = member_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_name571.Tree);
            	char_literal572=(IToken)Match(input,62,FOLLOW_62_in_property_declaration4255); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal572_tree = (object)adaptor.Create(char_literal572);
            		adaptor.AddChild(root_0, char_literal572_tree);
            	}
            	PushFollow(FOLLOW_accessor_declarations_in_property_declaration4259);
            	accessor_declarations573 = accessor_declarations();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_declarations573.Tree);
            	char_literal574=(IToken)Match(input,63,FOLLOW_63_in_property_declaration4263); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal574_tree = (object)adaptor.Create(char_literal574);
            		adaptor.AddChild(root_0, char_literal574_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 166, property_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "property_declaration"

    public class accessor_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "accessor_declarations"
    // G:\\downloads\\antlr\\cs.g:611:1: accessor_declarations : ( attributes )? ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? ) ;
    public csParser.accessor_declarations_return accessor_declarations() // throws RecognitionException [1]
    {   
        csParser.accessor_declarations_return retval = new csParser.accessor_declarations_return();
        retval.Start = input.LT(1);
        int accessor_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.attributes_return attributes575 = default(csParser.attributes_return);

        csParser.get_accessor_declaration_return get_accessor_declaration576 = default(csParser.get_accessor_declaration_return);

        csParser.attributes_return attributes577 = default(csParser.attributes_return);

        csParser.set_accessor_declaration_return set_accessor_declaration578 = default(csParser.set_accessor_declaration_return);

        csParser.set_accessor_declaration_return set_accessor_declaration579 = default(csParser.set_accessor_declaration_return);

        csParser.attributes_return attributes580 = default(csParser.attributes_return);

        csParser.get_accessor_declaration_return get_accessor_declaration581 = default(csParser.get_accessor_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 167) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:611:22: ( ( attributes )? ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? ) )
            // G:\\downloads\\antlr\\cs.g:612:2: ( attributes )? ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:612:2: ( attributes )?
            	int alt157 = 2;
            	int LA157_0 = input.LA(1);

            	if ( (LA157_0 == 86) )
            	{
            	    alt157 = 1;
            	}
            	switch (alt157) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:612:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_accessor_declarations4271);
            	        	attributes575 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes575.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:613:3: ( get_accessor_declaration ( attributes )? ( set_accessor_declaration )? | set_accessor_declaration ( attributes )? ( get_accessor_declaration )? )
            	int alt162 = 2;
            	switch ( input.LA(1) ) 
            	{
            	case 69:
            	case 70:
            	case 71:
            	case 72:
            		{
            	    int LA162_1 = input.LA(2);

            	    if ( (LA162_1 == 156) )
            	    {
            	        alt162 = 1;
            	    }
            	    else if ( (LA162_1 == 157) )
            	    {
            	        alt162 = 2;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        NoViableAltException nvae_d162s1 =
            	            new NoViableAltException("", 162, 1, input);

            	        throw nvae_d162s1;
            	    }
            	    }
            	    break;
            	case 156:
            		{
            	    alt162 = 1;
            	    }
            	    break;
            	case 157:
            		{
            	    alt162 = 2;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		    NoViableAltException nvae_d162s0 =
            		        new NoViableAltException("", 162, 0, input);

            		    throw nvae_d162s0;
            	}

            	switch (alt162) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:613:4: get_accessor_declaration ( attributes )? ( set_accessor_declaration )?
            	        {
            	        	PushFollow(FOLLOW_get_accessor_declaration_in_accessor_declarations4277);
            	        	get_accessor_declaration576 = get_accessor_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, get_accessor_declaration576.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:613:31: ( attributes )?
            	        	int alt158 = 2;
            	        	int LA158_0 = input.LA(1);

            	        	if ( (LA158_0 == 86) )
            	        	{
            	        	    alt158 = 1;
            	        	}
            	        	switch (alt158) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:613:31: attributes
            	        	        {
            	        	        	PushFollow(FOLLOW_attributes_in_accessor_declarations4281);
            	        	        	attributes577 = attributes();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes577.Tree);

            	        	        }
            	        	        break;

            	        	}

            	        	// G:\\downloads\\antlr\\cs.g:613:45: ( set_accessor_declaration )?
            	        	int alt159 = 2;
            	        	int LA159_0 = input.LA(1);

            	        	if ( ((LA159_0 >= 69 && LA159_0 <= 72) || LA159_0 == 157) )
            	        	{
            	        	    alt159 = 1;
            	        	}
            	        	switch (alt159) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:613:45: set_accessor_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_set_accessor_declaration_in_accessor_declarations4286);
            	        	        	set_accessor_declaration578 = set_accessor_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, set_accessor_declaration578.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:614:5: set_accessor_declaration ( attributes )? ( get_accessor_declaration )?
            	        {
            	        	PushFollow(FOLLOW_set_accessor_declaration_in_accessor_declarations4293);
            	        	set_accessor_declaration579 = set_accessor_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, set_accessor_declaration579.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:614:32: ( attributes )?
            	        	int alt160 = 2;
            	        	int LA160_0 = input.LA(1);

            	        	if ( (LA160_0 == 86) )
            	        	{
            	        	    alt160 = 1;
            	        	}
            	        	switch (alt160) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:614:32: attributes
            	        	        {
            	        	        	PushFollow(FOLLOW_attributes_in_accessor_declarations4297);
            	        	        	attributes580 = attributes();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes580.Tree);

            	        	        }
            	        	        break;

            	        	}

            	        	// G:\\downloads\\antlr\\cs.g:614:46: ( get_accessor_declaration )?
            	        	int alt161 = 2;
            	        	int LA161_0 = input.LA(1);

            	        	if ( ((LA161_0 >= 69 && LA161_0 <= 72) || LA161_0 == 156) )
            	        	{
            	        	    alt161 = 1;
            	        	}
            	        	switch (alt161) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:614:46: get_accessor_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_get_accessor_declaration_in_accessor_declarations4302);
            	        	        	get_accessor_declaration581 = get_accessor_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, get_accessor_declaration581.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 167, accessor_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "accessor_declarations"

    public class get_accessor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "get_accessor_declaration"
    // G:\\downloads\\antlr\\cs.g:615:1: get_accessor_declaration : ( accessor_modifier )? 'get' accessor_body ;
    public csParser.get_accessor_declaration_return get_accessor_declaration() // throws RecognitionException [1]
    {   
        csParser.get_accessor_declaration_return retval = new csParser.get_accessor_declaration_return();
        retval.Start = input.LT(1);
        int get_accessor_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal583 = null;
        csParser.accessor_modifier_return accessor_modifier582 = default(csParser.accessor_modifier_return);

        csParser.accessor_body_return accessor_body584 = default(csParser.accessor_body_return);


        object string_literal583_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 168) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:615:25: ( ( accessor_modifier )? 'get' accessor_body )
            // G:\\downloads\\antlr\\cs.g:616:2: ( accessor_modifier )? 'get' accessor_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:616:2: ( accessor_modifier )?
            	int alt163 = 2;
            	int LA163_0 = input.LA(1);

            	if ( ((LA163_0 >= 69 && LA163_0 <= 72)) )
            	{
            	    alt163 = 1;
            	}
            	switch (alt163) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:616:2: accessor_modifier
            	        {
            	        	PushFollow(FOLLOW_accessor_modifier_in_get_accessor_declaration4312);
            	        	accessor_modifier582 = accessor_modifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_modifier582.Tree);

            	        }
            	        break;

            	}

            	string_literal583=(IToken)Match(input,156,FOLLOW_156_in_get_accessor_declaration4317); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal583_tree = (object)adaptor.Create(string_literal583);
            		adaptor.AddChild(root_0, string_literal583_tree);
            	}
            	PushFollow(FOLLOW_accessor_body_in_get_accessor_declaration4321);
            	accessor_body584 = accessor_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_body584.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 168, get_accessor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "get_accessor_declaration"

    public class set_accessor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "set_accessor_declaration"
    // G:\\downloads\\antlr\\cs.g:617:1: set_accessor_declaration : ( accessor_modifier )? 'set' accessor_body ;
    public csParser.set_accessor_declaration_return set_accessor_declaration() // throws RecognitionException [1]
    {   
        csParser.set_accessor_declaration_return retval = new csParser.set_accessor_declaration_return();
        retval.Start = input.LT(1);
        int set_accessor_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal586 = null;
        csParser.accessor_modifier_return accessor_modifier585 = default(csParser.accessor_modifier_return);

        csParser.accessor_body_return accessor_body587 = default(csParser.accessor_body_return);


        object string_literal586_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 169) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:617:25: ( ( accessor_modifier )? 'set' accessor_body )
            // G:\\downloads\\antlr\\cs.g:618:2: ( accessor_modifier )? 'set' accessor_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:618:2: ( accessor_modifier )?
            	int alt164 = 2;
            	int LA164_0 = input.LA(1);

            	if ( ((LA164_0 >= 69 && LA164_0 <= 72)) )
            	{
            	    alt164 = 1;
            	}
            	switch (alt164) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:618:2: accessor_modifier
            	        {
            	        	PushFollow(FOLLOW_accessor_modifier_in_set_accessor_declaration4329);
            	        	accessor_modifier585 = accessor_modifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_modifier585.Tree);

            	        }
            	        break;

            	}

            	string_literal586=(IToken)Match(input,157,FOLLOW_157_in_set_accessor_declaration4334); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal586_tree = (object)adaptor.Create(string_literal586);
            		adaptor.AddChild(root_0, string_literal586_tree);
            	}
            	PushFollow(FOLLOW_accessor_body_in_set_accessor_declaration4338);
            	accessor_body587 = accessor_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_body587.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 169, set_accessor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "set_accessor_declaration"

    public class accessor_modifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "accessor_modifier"
    // G:\\downloads\\antlr\\cs.g:619:1: accessor_modifier : ( 'public' | 'protected' | 'private' | 'internal' );
    public csParser.accessor_modifier_return accessor_modifier() // throws RecognitionException [1]
    {   
        csParser.accessor_modifier_return retval = new csParser.accessor_modifier_return();
        retval.Start = input.LT(1);
        int accessor_modifier_StartIndex = input.Index();
        object root_0 = null;

        IToken set588 = null;

        object set588_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 170) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:619:18: ( 'public' | 'protected' | 'private' | 'internal' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set588 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 69 && input.LA(1) <= 72) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set588));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 170, accessor_modifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "accessor_modifier"

    public class accessor_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "accessor_body"
    // G:\\downloads\\antlr\\cs.g:621:1: accessor_body : block ;
    public csParser.accessor_body_return accessor_body() // throws RecognitionException [1]
    {   
        csParser.accessor_body_return retval = new csParser.accessor_body_return();
        retval.Start = input.LT(1);
        int accessor_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.block_return block589 = default(csParser.block_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 171) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:621:14: ( block )
            // G:\\downloads\\antlr\\cs.g:622:2: block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_block_in_accessor_body4366);
            	block589 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block589.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 171, accessor_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "accessor_body"

    public class event_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "event_declaration"
    // G:\\downloads\\antlr\\cs.g:625:1: event_declaration : 'event' type ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' ) ;
    public csParser.event_declaration_return event_declaration() // throws RecognitionException [1]
    {   
        csParser.event_declaration_return retval = new csParser.event_declaration_return();
        retval.Start = input.LT(1);
        int event_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal590 = null;
        IToken char_literal593 = null;
        IToken char_literal595 = null;
        IToken char_literal597 = null;
        csParser.type_return type591 = default(csParser.type_return);

        csParser.member_name_return member_name592 = default(csParser.member_name_return);

        csParser.event_accessor_declarations_return event_accessor_declarations594 = default(csParser.event_accessor_declarations_return);

        csParser.variable_declarators_return variable_declarators596 = default(csParser.variable_declarators_return);


        object string_literal590_tree=null;
        object char_literal593_tree=null;
        object char_literal595_tree=null;
        object char_literal597_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 172) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:625:18: ( 'event' type ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' ) )
            // G:\\downloads\\antlr\\cs.g:626:2: 'event' type ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal590=(IToken)Match(input,149,FOLLOW_149_in_event_declaration4376); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal590_tree = (object)adaptor.Create(string_literal590);
            		adaptor.AddChild(root_0, string_literal590_tree);
            	}
            	PushFollow(FOLLOW_type_in_event_declaration4380);
            	type591 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type591.Tree);
            	// G:\\downloads\\antlr\\cs.g:627:3: ( ( member_name '{' )=> member_name '{' event_accessor_declarations '}' | variable_declarators ';' )
            	int alt165 = 2;
            	int LA165_0 = input.LA(1);

            	if ( ((LA165_0 >= 160 && LA165_0 <= 168) || (LA165_0 >= 196 && LA165_0 <= 201)) && (synpred25_cs()) )
            	{
            	    alt165 = 1;
            	}
            	else if ( (LA165_0 == IDENTIFIER || LA165_0 == 65 || (LA165_0 >= 132 && LA165_0 <= 133) || (LA165_0 >= 135 && LA165_0 <= 148) || (LA165_0 >= 150 && LA165_0 <= 152) || LA165_0 == 154 || (LA165_0 >= 157 && LA165_0 <= 159) || LA165_0 == 170 || (LA165_0 >= 177 && LA165_0 <= 178) || LA165_0 == 195 || LA165_0 == 202) )
            	{
            	    int LA165_2 = input.LA(2);

            	    if ( (synpred25_cs()) )
            	    {
            	        alt165 = 1;
            	    }
            	    else if ( (true) )
            	    {
            	        alt165 = 2;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        NoViableAltException nvae_d165s2 =
            	            new NoViableAltException("", 165, 2, input);

            	        throw nvae_d165s2;
            	    }
            	}
            	else if ( ((LA165_0 >= Real_literal && LA165_0 <= NULL)) && (synpred25_cs()) )
            	{
            	    alt165 = 1;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d165s0 =
            	        new NoViableAltException("", 165, 0, input);

            	    throw nvae_d165s0;
            	}
            	switch (alt165) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:627:4: ( member_name '{' )=> member_name '{' event_accessor_declarations '}'
            	        {
            	        	PushFollow(FOLLOW_member_name_in_event_declaration4395);
            	        	member_name592 = member_name();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, member_name592.Tree);
            	        	char_literal593=(IToken)Match(input,62,FOLLOW_62_in_event_declaration4399); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal593_tree = (object)adaptor.Create(char_literal593);
            	        		adaptor.AddChild(root_0, char_literal593_tree);
            	        	}
            	        	PushFollow(FOLLOW_event_accessor_declarations_in_event_declaration4403);
            	        	event_accessor_declarations594 = event_accessor_declarations();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, event_accessor_declarations594.Tree);
            	        	char_literal595=(IToken)Match(input,63,FOLLOW_63_in_event_declaration4407); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal595_tree = (object)adaptor.Create(char_literal595);
            	        		adaptor.AddChild(root_0, char_literal595_tree);
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:628:5: variable_declarators ';'
            	        {
            	        	PushFollow(FOLLOW_variable_declarators_in_event_declaration4413);
            	        	variable_declarators596 = variable_declarators();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variable_declarators596.Tree);
            	        	char_literal597=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_event_declaration4417); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal597_tree = (object)adaptor.Create(char_literal597);
            	        		adaptor.AddChild(root_0, char_literal597_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 172, event_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "event_declaration"

    public class event_modifiers_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "event_modifiers"
    // G:\\downloads\\antlr\\cs.g:630:1: event_modifiers : ( modifier )+ ;
    public csParser.event_modifiers_return event_modifiers() // throws RecognitionException [1]
    {   
        csParser.event_modifiers_return retval = new csParser.event_modifiers_return();
        retval.Start = input.LT(1);
        int event_modifiers_StartIndex = input.Index();
        object root_0 = null;

        csParser.modifier_return modifier598 = default(csParser.modifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 173) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:630:16: ( ( modifier )+ )
            // G:\\downloads\\antlr\\cs.g:631:2: ( modifier )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:631:2: ( modifier )+
            	int cnt166 = 0;
            	do 
            	{
            	    int alt166 = 2;
            	    int LA166_0 = input.LA(1);

            	    if ( (LA166_0 == 64 || (LA166_0 >= 68 && LA166_0 <= 80)) )
            	    {
            	        alt166 = 1;
            	    }


            	    switch (alt166) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:631:2: modifier
            			    {
            			    	PushFollow(FOLLOW_modifier_in_event_modifiers4429);
            			    	modifier598 = modifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier598.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt166 >= 1 ) goto loop166;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(166, input);
            		            throw eee;
            	    }
            	    cnt166++;
            	} while (true);

            	loop166:
            		;	// Stops C# compiler whinging that label 'loop166' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 173, event_modifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "event_modifiers"

    public class event_accessor_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "event_accessor_declarations"
    // G:\\downloads\\antlr\\cs.g:632:1: event_accessor_declarations : ( attributes )? ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) ) ;
    public csParser.event_accessor_declarations_return event_accessor_declarations() // throws RecognitionException [1]
    {   
        csParser.event_accessor_declarations_return retval = new csParser.event_accessor_declarations_return();
        retval.Start = input.LT(1);
        int event_accessor_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.attributes_return attributes599 = default(csParser.attributes_return);

        csParser.add_accessor_declaration_return add_accessor_declaration600 = default(csParser.add_accessor_declaration_return);

        csParser.attributes_return attributes601 = default(csParser.attributes_return);

        csParser.remove_accessor_declaration_return remove_accessor_declaration602 = default(csParser.remove_accessor_declaration_return);

        csParser.remove_accessor_declaration_return remove_accessor_declaration603 = default(csParser.remove_accessor_declaration_return);

        csParser.attributes_return attributes604 = default(csParser.attributes_return);

        csParser.add_accessor_declaration_return add_accessor_declaration605 = default(csParser.add_accessor_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 174) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:632:28: ( ( attributes )? ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) ) )
            // G:\\downloads\\antlr\\cs.g:633:2: ( attributes )? ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:633:2: ( attributes )?
            	int alt167 = 2;
            	int LA167_0 = input.LA(1);

            	if ( (LA167_0 == 86) )
            	{
            	    alt167 = 1;
            	}
            	switch (alt167) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:633:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_event_accessor_declarations4438);
            	        	attributes599 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes599.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:633:16: ( ( add_accessor_declaration ( attributes )? remove_accessor_declaration ) | ( remove_accessor_declaration ( attributes )? add_accessor_declaration ) )
            	int alt170 = 2;
            	int LA170_0 = input.LA(1);

            	if ( (LA170_0 == 158) )
            	{
            	    alt170 = 1;
            	}
            	else if ( (LA170_0 == 159) )
            	{
            	    alt170 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d170s0 =
            	        new NoViableAltException("", 170, 0, input);

            	    throw nvae_d170s0;
            	}
            	switch (alt170) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:633:17: ( add_accessor_declaration ( attributes )? remove_accessor_declaration )
            	        {
            	        	// G:\\downloads\\antlr\\cs.g:633:17: ( add_accessor_declaration ( attributes )? remove_accessor_declaration )
            	        	// G:\\downloads\\antlr\\cs.g:633:18: add_accessor_declaration ( attributes )? remove_accessor_declaration
            	        	{
            	        		PushFollow(FOLLOW_add_accessor_declaration_in_event_accessor_declarations4445);
            	        		add_accessor_declaration600 = add_accessor_declaration();
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, add_accessor_declaration600.Tree);
            	        		// G:\\downloads\\antlr\\cs.g:633:45: ( attributes )?
            	        		int alt168 = 2;
            	        		int LA168_0 = input.LA(1);

            	        		if ( (LA168_0 == 86) )
            	        		{
            	        		    alt168 = 1;
            	        		}
            	        		switch (alt168) 
            	        		{
            	        		    case 1 :
            	        		        // G:\\downloads\\antlr\\cs.g:633:45: attributes
            	        		        {
            	        		        	PushFollow(FOLLOW_attributes_in_event_accessor_declarations4449);
            	        		        	attributes601 = attributes();
            	        		        	state.followingStackPointer--;
            	        		        	if (state.failed) return retval;
            	        		        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes601.Tree);

            	        		        }
            	        		        break;

            	        		}

            	        		PushFollow(FOLLOW_remove_accessor_declaration_in_event_accessor_declarations4454);
            	        		remove_accessor_declaration602 = remove_accessor_declaration();
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, remove_accessor_declaration602.Tree);

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:634:18: ( remove_accessor_declaration ( attributes )? add_accessor_declaration )
            	        {
            	        	// G:\\downloads\\antlr\\cs.g:634:18: ( remove_accessor_declaration ( attributes )? add_accessor_declaration )
            	        	// G:\\downloads\\antlr\\cs.g:634:19: remove_accessor_declaration ( attributes )? add_accessor_declaration
            	        	{
            	        		PushFollow(FOLLOW_remove_accessor_declaration_in_event_accessor_declarations4475);
            	        		remove_accessor_declaration603 = remove_accessor_declaration();
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, remove_accessor_declaration603.Tree);
            	        		// G:\\downloads\\antlr\\cs.g:634:49: ( attributes )?
            	        		int alt169 = 2;
            	        		int LA169_0 = input.LA(1);

            	        		if ( (LA169_0 == 86) )
            	        		{
            	        		    alt169 = 1;
            	        		}
            	        		switch (alt169) 
            	        		{
            	        		    case 1 :
            	        		        // G:\\downloads\\antlr\\cs.g:634:49: attributes
            	        		        {
            	        		        	PushFollow(FOLLOW_attributes_in_event_accessor_declarations4479);
            	        		        	attributes604 = attributes();
            	        		        	state.followingStackPointer--;
            	        		        	if (state.failed) return retval;
            	        		        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes604.Tree);

            	        		        }
            	        		        break;

            	        		}

            	        		PushFollow(FOLLOW_add_accessor_declaration_in_event_accessor_declarations4484);
            	        		add_accessor_declaration605 = add_accessor_declaration();
            	        		state.followingStackPointer--;
            	        		if (state.failed) return retval;
            	        		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, add_accessor_declaration605.Tree);

            	        	}


            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 174, event_accessor_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "event_accessor_declarations"

    public class add_accessor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "add_accessor_declaration"
    // G:\\downloads\\antlr\\cs.g:635:1: add_accessor_declaration : 'add' block ;
    public csParser.add_accessor_declaration_return add_accessor_declaration() // throws RecognitionException [1]
    {   
        csParser.add_accessor_declaration_return retval = new csParser.add_accessor_declaration_return();
        retval.Start = input.LT(1);
        int add_accessor_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal606 = null;
        csParser.block_return block607 = default(csParser.block_return);


        object string_literal606_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 175) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:635:25: ( 'add' block )
            // G:\\downloads\\antlr\\cs.g:636:2: 'add' block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal606=(IToken)Match(input,158,FOLLOW_158_in_add_accessor_declaration4494); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal606_tree = (object)adaptor.Create(string_literal606);
            		adaptor.AddChild(root_0, string_literal606_tree);
            	}
            	PushFollow(FOLLOW_block_in_add_accessor_declaration4498);
            	block607 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block607.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 175, add_accessor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "add_accessor_declaration"

    public class remove_accessor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "remove_accessor_declaration"
    // G:\\downloads\\antlr\\cs.g:637:1: remove_accessor_declaration : 'remove' block ;
    public csParser.remove_accessor_declaration_return remove_accessor_declaration() // throws RecognitionException [1]
    {   
        csParser.remove_accessor_declaration_return retval = new csParser.remove_accessor_declaration_return();
        retval.Start = input.LT(1);
        int remove_accessor_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal608 = null;
        csParser.block_return block609 = default(csParser.block_return);


        object string_literal608_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 176) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:637:28: ( 'remove' block )
            // G:\\downloads\\antlr\\cs.g:638:2: 'remove' block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal608=(IToken)Match(input,159,FOLLOW_159_in_remove_accessor_declaration4506); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal608_tree = (object)adaptor.Create(string_literal608);
            		adaptor.AddChild(root_0, string_literal608_tree);
            	}
            	PushFollow(FOLLOW_block_in_remove_accessor_declaration4510);
            	block609 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block609.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 176, remove_accessor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "remove_accessor_declaration"

    public class enum_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "enum_declaration"
    // G:\\downloads\\antlr\\cs.g:643:1: enum_declaration : 'enum' identifier ( enum_base )? enum_body ( ';' )? ;
    public csParser.enum_declaration_return enum_declaration() // throws RecognitionException [1]
    {   
        csParser.enum_declaration_return retval = new csParser.enum_declaration_return();
        retval.Start = input.LT(1);
        int enum_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal610 = null;
        IToken char_literal614 = null;
        csParser.identifier_return identifier611 = default(csParser.identifier_return);

        csParser.enum_base_return enum_base612 = default(csParser.enum_base_return);

        csParser.enum_body_return enum_body613 = default(csParser.enum_body_return);


        object string_literal610_tree=null;
        object char_literal614_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 177) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:643:17: ( 'enum' identifier ( enum_base )? enum_body ( ';' )? )
            // G:\\downloads\\antlr\\cs.g:644:2: 'enum' identifier ( enum_base )? enum_body ( ';' )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal610=(IToken)Match(input,ENUM,FOLLOW_ENUM_in_enum_declaration4522); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal610_tree = (object)adaptor.Create(string_literal610);
            		adaptor.AddChild(root_0, string_literal610_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_enum_declaration4526);
            	identifier611 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier611.Tree);
            	// G:\\downloads\\antlr\\cs.g:644:24: ( enum_base )?
            	int alt171 = 2;
            	int LA171_0 = input.LA(1);

            	if ( (LA171_0 == 90) )
            	{
            	    alt171 = 1;
            	}
            	switch (alt171) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:644:24: enum_base
            	        {
            	        	PushFollow(FOLLOW_enum_base_in_enum_declaration4530);
            	        	enum_base612 = enum_base();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_base612.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_enum_body_in_enum_declaration4535);
            	enum_body613 = enum_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_body613.Tree);
            	// G:\\downloads\\antlr\\cs.g:644:49: ( ';' )?
            	int alt172 = 2;
            	int LA172_0 = input.LA(1);

            	if ( (LA172_0 == SEMI) )
            	{
            	    alt172 = 1;
            	}
            	switch (alt172) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:644:49: ';'
            	        {
            	        	char_literal614=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_enum_declaration4539); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal614_tree = (object)adaptor.Create(char_literal614);
            	        		adaptor.AddChild(root_0, char_literal614_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 177, enum_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "enum_declaration"

    public class enum_base_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "enum_base"
    // G:\\downloads\\antlr\\cs.g:645:1: enum_base : ':' integral_type ;
    public csParser.enum_base_return enum_base() // throws RecognitionException [1]
    {   
        csParser.enum_base_return retval = new csParser.enum_base_return();
        retval.Start = input.LT(1);
        int enum_base_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal615 = null;
        csParser.integral_type_return integral_type616 = default(csParser.integral_type_return);


        object char_literal615_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 178) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:645:10: ( ':' integral_type )
            // G:\\downloads\\antlr\\cs.g:646:2: ':' integral_type
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal615=(IToken)Match(input,90,FOLLOW_90_in_enum_base4548); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal615_tree = (object)adaptor.Create(char_literal615);
            		adaptor.AddChild(root_0, char_literal615_tree);
            	}
            	PushFollow(FOLLOW_integral_type_in_enum_base4552);
            	integral_type616 = integral_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, integral_type616.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 178, enum_base_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "enum_base"

    public class enum_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "enum_body"
    // G:\\downloads\\antlr\\cs.g:647:1: enum_body : '{' ( enum_member_declarations ( ',' )? )? '}' ;
    public csParser.enum_body_return enum_body() // throws RecognitionException [1]
    {   
        csParser.enum_body_return retval = new csParser.enum_body_return();
        retval.Start = input.LT(1);
        int enum_body_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal617 = null;
        IToken char_literal619 = null;
        IToken char_literal620 = null;
        csParser.enum_member_declarations_return enum_member_declarations618 = default(csParser.enum_member_declarations_return);


        object char_literal617_tree=null;
        object char_literal619_tree=null;
        object char_literal620_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 179) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:647:10: ( '{' ( enum_member_declarations ( ',' )? )? '}' )
            // G:\\downloads\\antlr\\cs.g:648:2: '{' ( enum_member_declarations ( ',' )? )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal617=(IToken)Match(input,62,FOLLOW_62_in_enum_body4560); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal617_tree = (object)adaptor.Create(char_literal617);
            		adaptor.AddChild(root_0, char_literal617_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:648:6: ( enum_member_declarations ( ',' )? )?
            	int alt174 = 2;
            	int LA174_0 = input.LA(1);

            	if ( (LA174_0 == IDENTIFIER || LA174_0 == 65 || LA174_0 == 86 || (LA174_0 >= 132 && LA174_0 <= 133) || (LA174_0 >= 135 && LA174_0 <= 148) || (LA174_0 >= 150 && LA174_0 <= 152) || LA174_0 == 154 || (LA174_0 >= 157 && LA174_0 <= 159) || LA174_0 == 170 || (LA174_0 >= 177 && LA174_0 <= 178) || LA174_0 == 195 || LA174_0 == 202) )
            	{
            	    alt174 = 1;
            	}
            	switch (alt174) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:648:7: enum_member_declarations ( ',' )?
            	        {
            	        	PushFollow(FOLLOW_enum_member_declarations_in_enum_body4563);
            	        	enum_member_declarations618 = enum_member_declarations();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_member_declarations618.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:648:32: ( ',' )?
            	        	int alt173 = 2;
            	        	int LA173_0 = input.LA(1);

            	        	if ( (LA173_0 == 89) )
            	        	{
            	        	    alt173 = 1;
            	        	}
            	        	switch (alt173) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:648:32: ','
            	        	        {
            	        	        	char_literal619=(IToken)Match(input,89,FOLLOW_89_in_enum_body4565); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 )
            	        	        	{char_literal619_tree = (object)adaptor.Create(char_literal619);
            	        	        		adaptor.AddChild(root_0, char_literal619_tree);
            	        	        	}

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;

            	}

            	char_literal620=(IToken)Match(input,63,FOLLOW_63_in_enum_body4572); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal620_tree = (object)adaptor.Create(char_literal620);
            		adaptor.AddChild(root_0, char_literal620_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 179, enum_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "enum_body"

    public class enum_member_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "enum_member_declarations"
    // G:\\downloads\\antlr\\cs.g:649:1: enum_member_declarations : enum_member_declaration ( ',' enum_member_declaration )* ;
    public csParser.enum_member_declarations_return enum_member_declarations() // throws RecognitionException [1]
    {   
        csParser.enum_member_declarations_return retval = new csParser.enum_member_declarations_return();
        retval.Start = input.LT(1);
        int enum_member_declarations_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal622 = null;
        csParser.enum_member_declaration_return enum_member_declaration621 = default(csParser.enum_member_declaration_return);

        csParser.enum_member_declaration_return enum_member_declaration623 = default(csParser.enum_member_declaration_return);


        object char_literal622_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 180) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:649:25: ( enum_member_declaration ( ',' enum_member_declaration )* )
            // G:\\downloads\\antlr\\cs.g:650:2: enum_member_declaration ( ',' enum_member_declaration )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_enum_member_declaration_in_enum_member_declarations4580);
            	enum_member_declaration621 = enum_member_declaration();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_member_declaration621.Tree);
            	// G:\\downloads\\antlr\\cs.g:650:26: ( ',' enum_member_declaration )*
            	do 
            	{
            	    int alt175 = 2;
            	    int LA175_0 = input.LA(1);

            	    if ( (LA175_0 == 89) )
            	    {
            	        int LA175_1 = input.LA(2);

            	        if ( (LA175_1 == IDENTIFIER || LA175_1 == 65 || LA175_1 == 86 || (LA175_1 >= 132 && LA175_1 <= 133) || (LA175_1 >= 135 && LA175_1 <= 148) || (LA175_1 >= 150 && LA175_1 <= 152) || LA175_1 == 154 || (LA175_1 >= 157 && LA175_1 <= 159) || LA175_1 == 170 || (LA175_1 >= 177 && LA175_1 <= 178) || LA175_1 == 195 || LA175_1 == 202) )
            	        {
            	            alt175 = 1;
            	        }


            	    }


            	    switch (alt175) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:650:27: ',' enum_member_declaration
            			    {
            			    	char_literal622=(IToken)Match(input,89,FOLLOW_89_in_enum_member_declarations4583); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal622_tree = (object)adaptor.Create(char_literal622);
            			    		adaptor.AddChild(root_0, char_literal622_tree);
            			    	}
            			    	PushFollow(FOLLOW_enum_member_declaration_in_enum_member_declarations4585);
            			    	enum_member_declaration623 = enum_member_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_member_declaration623.Tree);

            			    }
            			    break;

            			default:
            			    goto loop175;
            	    }
            	} while (true);

            	loop175:
            		;	// Stops C# compiler whining that label 'loop175' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 180, enum_member_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "enum_member_declarations"

    public class enum_member_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "enum_member_declaration"
    // G:\\downloads\\antlr\\cs.g:651:1: enum_member_declaration : ( attributes )? identifier ( '=' expression )? ;
    public csParser.enum_member_declaration_return enum_member_declaration() // throws RecognitionException [1]
    {   
        csParser.enum_member_declaration_return retval = new csParser.enum_member_declaration_return();
        retval.Start = input.LT(1);
        int enum_member_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal626 = null;
        csParser.attributes_return attributes624 = default(csParser.attributes_return);

        csParser.identifier_return identifier625 = default(csParser.identifier_return);

        csParser.expression_return expression627 = default(csParser.expression_return);


        object char_literal626_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 181) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:651:24: ( ( attributes )? identifier ( '=' expression )? )
            // G:\\downloads\\antlr\\cs.g:652:2: ( attributes )? identifier ( '=' expression )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:652:2: ( attributes )?
            	int alt176 = 2;
            	int LA176_0 = input.LA(1);

            	if ( (LA176_0 == 86) )
            	{
            	    alt176 = 1;
            	}
            	switch (alt176) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:652:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_enum_member_declaration4595);
            	        	attributes624 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes624.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_identifier_in_enum_member_declaration4600);
            	identifier625 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier625.Tree);
            	// G:\\downloads\\antlr\\cs.g:652:29: ( '=' expression )?
            	int alt177 = 2;
            	int LA177_0 = input.LA(1);

            	if ( (LA177_0 == 66) )
            	{
            	    alt177 = 1;
            	}
            	switch (alt177) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:652:30: '=' expression
            	        {
            	        	char_literal626=(IToken)Match(input,66,FOLLOW_66_in_enum_member_declaration4605); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal626_tree = (object)adaptor.Create(char_literal626);
            	        		adaptor.AddChild(root_0, char_literal626_tree);
            	        	}
            	        	PushFollow(FOLLOW_expression_in_enum_member_declaration4609);
            	        	expression627 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression627.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 181, enum_member_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "enum_member_declaration"

    public class integral_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "integral_type"
    // G:\\downloads\\antlr\\cs.g:657:1: integral_type : ( 'sbyte' | 'byte' | 'short' | 'ushort' | 'int' | 'uint' | 'long' | 'ulong' | 'char' );
    public csParser.integral_type_return integral_type() // throws RecognitionException [1]
    {   
        csParser.integral_type_return retval = new csParser.integral_type_return();
        retval.Start = input.LT(1);
        int integral_type_StartIndex = input.Index();
        object root_0 = null;

        IToken set628 = null;

        object set628_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 182) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:657:14: ( 'sbyte' | 'byte' | 'short' | 'ushort' | 'int' | 'uint' | 'long' | 'ulong' | 'char' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set628 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 160 && input.LA(1) <= 168) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set628));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 182, integral_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "integral_type"

    public class delegate_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "delegate_declaration"
    // G:\\downloads\\antlr\\cs.g:661:1: delegate_declaration : 'delegate' return_type identifier ( variant_generic_parameter_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' ;
    public csParser.delegate_declaration_return delegate_declaration() // throws RecognitionException [1]
    {   
        csParser.delegate_declaration_return retval = new csParser.delegate_declaration_return();
        retval.Start = input.LT(1);
        int delegate_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal629 = null;
        IToken char_literal633 = null;
        IToken char_literal635 = null;
        IToken char_literal637 = null;
        csParser.return_type_return return_type630 = default(csParser.return_type_return);

        csParser.identifier_return identifier631 = default(csParser.identifier_return);

        csParser.variant_generic_parameter_list_return variant_generic_parameter_list632 = default(csParser.variant_generic_parameter_list_return);

        csParser.formal_parameter_list_return formal_parameter_list634 = default(csParser.formal_parameter_list_return);

        csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses636 = default(csParser.type_parameter_constraints_clauses_return);


        object string_literal629_tree=null;
        object char_literal633_tree=null;
        object char_literal635_tree=null;
        object char_literal637_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 183) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:661:21: ( 'delegate' return_type identifier ( variant_generic_parameter_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' )
            // G:\\downloads\\antlr\\cs.g:662:2: 'delegate' return_type identifier ( variant_generic_parameter_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal629=(IToken)Match(input,97,FOLLOW_97_in_delegate_declaration4666); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal629_tree = (object)adaptor.Create(string_literal629);
            		adaptor.AddChild(root_0, string_literal629_tree);
            	}
            	PushFollow(FOLLOW_return_type_in_delegate_declaration4670);
            	return_type630 = return_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, return_type630.Tree);
            	PushFollow(FOLLOW_identifier_in_delegate_declaration4674);
            	identifier631 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier631.Tree);
            	// G:\\downloads\\antlr\\cs.g:662:41: ( variant_generic_parameter_list )?
            	int alt178 = 2;
            	int LA178_0 = input.LA(1);

            	if ( (LA178_0 == 99) )
            	{
            	    alt178 = 1;
            	}
            	switch (alt178) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:662:41: variant_generic_parameter_list
            	        {
            	        	PushFollow(FOLLOW_variant_generic_parameter_list_in_delegate_declaration4677);
            	        	variant_generic_parameter_list632 = variant_generic_parameter_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_generic_parameter_list632.Tree);

            	        }
            	        break;

            	}

            	char_literal633=(IToken)Match(input,88,FOLLOW_88_in_delegate_declaration4685); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal633_tree = (object)adaptor.Create(char_literal633);
            		adaptor.AddChild(root_0, char_literal633_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:663:9: ( formal_parameter_list )?
            	int alt179 = 2;
            	int LA179_0 = input.LA(1);

            	if ( (LA179_0 == IDENTIFIER || LA179_0 == 65 || (LA179_0 >= 82 && LA179_0 <= 83) || LA179_0 == 86 || (LA179_0 >= 91 && LA179_0 <= 92) || (LA179_0 >= 132 && LA179_0 <= 133) || (LA179_0 >= 135 && LA179_0 <= 148) || (LA179_0 >= 150 && LA179_0 <= 152) || LA179_0 == 154 || (LA179_0 >= 157 && LA179_0 <= 168) || (LA179_0 >= 170 && LA179_0 <= 171) || (LA179_0 >= 177 && LA179_0 <= 178) || (LA179_0 >= 195 && LA179_0 <= 202)) )
            	{
            	    alt179 = 1;
            	}
            	switch (alt179) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:663:9: formal_parameter_list
            	        {
            	        	PushFollow(FOLLOW_formal_parameter_list_in_delegate_declaration4689);
            	        	formal_parameter_list634 = formal_parameter_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list634.Tree);

            	        }
            	        break;

            	}

            	char_literal635=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_delegate_declaration4694); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal635_tree = (object)adaptor.Create(char_literal635);
            		adaptor.AddChild(root_0, char_literal635_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:663:40: ( type_parameter_constraints_clauses )?
            	int alt180 = 2;
            	int LA180_0 = input.LA(1);

            	if ( (LA180_0 == 145) )
            	{
            	    alt180 = 1;
            	}
            	switch (alt180) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:663:40: type_parameter_constraints_clauses
            	        {
            	        	PushFollow(FOLLOW_type_parameter_constraints_clauses_in_delegate_declaration4698);
            	        	type_parameter_constraints_clauses636 = type_parameter_constraints_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses636.Tree);

            	        }
            	        break;

            	}

            	char_literal637=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_delegate_declaration4703); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal637_tree = (object)adaptor.Create(char_literal637);
            		adaptor.AddChild(root_0, char_literal637_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 183, delegate_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "delegate_declaration"

    public class delegate_modifiers_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "delegate_modifiers"
    // G:\\downloads\\antlr\\cs.g:664:1: delegate_modifiers : ( modifier )+ ;
    public csParser.delegate_modifiers_return delegate_modifiers() // throws RecognitionException [1]
    {   
        csParser.delegate_modifiers_return retval = new csParser.delegate_modifiers_return();
        retval.Start = input.LT(1);
        int delegate_modifiers_StartIndex = input.Index();
        object root_0 = null;

        csParser.modifier_return modifier638 = default(csParser.modifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 184) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:664:19: ( ( modifier )+ )
            // G:\\downloads\\antlr\\cs.g:665:2: ( modifier )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:665:2: ( modifier )+
            	int cnt181 = 0;
            	do 
            	{
            	    int alt181 = 2;
            	    int LA181_0 = input.LA(1);

            	    if ( (LA181_0 == 64 || (LA181_0 >= 68 && LA181_0 <= 80)) )
            	    {
            	        alt181 = 1;
            	    }


            	    switch (alt181) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:665:2: modifier
            			    {
            			    	PushFollow(FOLLOW_modifier_in_delegate_modifiers4711);
            			    	modifier638 = modifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier638.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt181 >= 1 ) goto loop181;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(181, input);
            		            throw eee;
            	    }
            	    cnt181++;
            	} while (true);

            	loop181:
            		;	// Stops C# compiler whinging that label 'loop181' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 184, delegate_modifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "delegate_modifiers"

    public class variant_generic_parameter_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variant_generic_parameter_list"
    // G:\\downloads\\antlr\\cs.g:667:1: variant_generic_parameter_list : '<' variant_type_parameters '>' ;
    public csParser.variant_generic_parameter_list_return variant_generic_parameter_list() // throws RecognitionException [1]
    {   
        csParser.variant_generic_parameter_list_return retval = new csParser.variant_generic_parameter_list_return();
        retval.Start = input.LT(1);
        int variant_generic_parameter_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal639 = null;
        IToken char_literal641 = null;
        csParser.variant_type_parameters_return variant_type_parameters640 = default(csParser.variant_type_parameters_return);


        object char_literal639_tree=null;
        object char_literal641_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 185) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:667:31: ( '<' variant_type_parameters '>' )
            // G:\\downloads\\antlr\\cs.g:668:2: '<' variant_type_parameters '>'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal639=(IToken)Match(input,99,FOLLOW_99_in_variant_generic_parameter_list4721); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal639_tree = (object)adaptor.Create(char_literal639);
            		adaptor.AddChild(root_0, char_literal639_tree);
            	}
            	PushFollow(FOLLOW_variant_type_parameters_in_variant_generic_parameter_list4725);
            	variant_type_parameters640 = variant_type_parameters();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_type_parameters640.Tree);
            	char_literal641=(IToken)Match(input,GT,FOLLOW_GT_in_variant_generic_parameter_list4729); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal641_tree = (object)adaptor.Create(char_literal641);
            		adaptor.AddChild(root_0, char_literal641_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 185, variant_generic_parameter_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variant_generic_parameter_list"

    public class variant_type_parameters_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variant_type_parameters"
    // G:\\downloads\\antlr\\cs.g:669:1: variant_type_parameters : variant_type_variable_name ( ',' variant_type_variable_name )* ;
    public csParser.variant_type_parameters_return variant_type_parameters() // throws RecognitionException [1]
    {   
        csParser.variant_type_parameters_return retval = new csParser.variant_type_parameters_return();
        retval.Start = input.LT(1);
        int variant_type_parameters_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal643 = null;
        csParser.variant_type_variable_name_return variant_type_variable_name642 = default(csParser.variant_type_variable_name_return);

        csParser.variant_type_variable_name_return variant_type_variable_name644 = default(csParser.variant_type_variable_name_return);


        object char_literal643_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 186) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:669:24: ( variant_type_variable_name ( ',' variant_type_variable_name )* )
            // G:\\downloads\\antlr\\cs.g:670:2: variant_type_variable_name ( ',' variant_type_variable_name )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_variant_type_variable_name_in_variant_type_parameters4737);
            	variant_type_variable_name642 = variant_type_variable_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_type_variable_name642.Tree);
            	// G:\\downloads\\antlr\\cs.g:670:29: ( ',' variant_type_variable_name )*
            	do 
            	{
            	    int alt182 = 2;
            	    int LA182_0 = input.LA(1);

            	    if ( (LA182_0 == 89) )
            	    {
            	        alt182 = 1;
            	    }


            	    switch (alt182) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:670:30: ',' variant_type_variable_name
            			    {
            			    	char_literal643=(IToken)Match(input,89,FOLLOW_89_in_variant_type_parameters4740); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal643_tree = (object)adaptor.Create(char_literal643);
            			    		adaptor.AddChild(root_0, char_literal643_tree);
            			    	}
            			    	PushFollow(FOLLOW_variant_type_variable_name_in_variant_type_parameters4742);
            			    	variant_type_variable_name644 = variant_type_variable_name();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_type_variable_name644.Tree);

            			    }
            			    break;

            			default:
            			    goto loop182;
            	    }
            	} while (true);

            	loop182:
            		;	// Stops C# compiler whining that label 'loop182' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 186, variant_type_parameters_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variant_type_parameters"

    public class variant_type_variable_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variant_type_variable_name"
    // G:\\downloads\\antlr\\cs.g:671:1: variant_type_variable_name : ( attributes )? ( variance_annotation )? type_variable_name ;
    public csParser.variant_type_variable_name_return variant_type_variable_name() // throws RecognitionException [1]
    {   
        csParser.variant_type_variable_name_return retval = new csParser.variant_type_variable_name_return();
        retval.Start = input.LT(1);
        int variant_type_variable_name_StartIndex = input.Index();
        object root_0 = null;

        csParser.attributes_return attributes645 = default(csParser.attributes_return);

        csParser.variance_annotation_return variance_annotation646 = default(csParser.variance_annotation_return);

        csParser.type_variable_name_return type_variable_name647 = default(csParser.type_variable_name_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 187) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:671:27: ( ( attributes )? ( variance_annotation )? type_variable_name )
            // G:\\downloads\\antlr\\cs.g:672:2: ( attributes )? ( variance_annotation )? type_variable_name
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:672:2: ( attributes )?
            	int alt183 = 2;
            	int LA183_0 = input.LA(1);

            	if ( (LA183_0 == 86) )
            	{
            	    alt183 = 1;
            	}
            	switch (alt183) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:672:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_variant_type_variable_name4752);
            	        	attributes645 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes645.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:672:16: ( variance_annotation )?
            	int alt184 = 2;
            	int LA184_0 = input.LA(1);

            	if ( (LA184_0 == 91 || LA184_0 == 134) )
            	{
            	    alt184 = 1;
            	}
            	switch (alt184) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:672:16: variance_annotation
            	        {
            	        	PushFollow(FOLLOW_variance_annotation_in_variant_type_variable_name4757);
            	        	variance_annotation646 = variance_annotation();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variance_annotation646.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_type_variable_name_in_variant_type_variable_name4762);
            	type_variable_name647 = type_variable_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_variable_name647.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 187, variant_type_variable_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variant_type_variable_name"

    public class variance_annotation_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variance_annotation"
    // G:\\downloads\\antlr\\cs.g:673:1: variance_annotation : ( 'in' | 'out' );
    public csParser.variance_annotation_return variance_annotation() // throws RecognitionException [1]
    {   
        csParser.variance_annotation_return retval = new csParser.variance_annotation_return();
        retval.Start = input.LT(1);
        int variance_annotation_StartIndex = input.Index();
        object root_0 = null;

        IToken set648 = null;

        object set648_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 188) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:673:20: ( 'in' | 'out' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set648 = (IToken)input.LT(1);
            	if ( input.LA(1) == 91 || input.LA(1) == 134 ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set648));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 188, variance_annotation_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variance_annotation"

    public class type_parameter_constraints_clauses_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_parameter_constraints_clauses"
    // G:\\downloads\\antlr\\cs.g:676:1: type_parameter_constraints_clauses : type_parameter_constraints_clause ( ',' type_parameter_constraints_clause )* ;
    public csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses() // throws RecognitionException [1]
    {   
        csParser.type_parameter_constraints_clauses_return retval = new csParser.type_parameter_constraints_clauses_return();
        retval.Start = input.LT(1);
        int type_parameter_constraints_clauses_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal650 = null;
        csParser.type_parameter_constraints_clause_return type_parameter_constraints_clause649 = default(csParser.type_parameter_constraints_clause_return);

        csParser.type_parameter_constraints_clause_return type_parameter_constraints_clause651 = default(csParser.type_parameter_constraints_clause_return);


        object char_literal650_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 189) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:676:35: ( type_parameter_constraints_clause ( ',' type_parameter_constraints_clause )* )
            // G:\\downloads\\antlr\\cs.g:677:2: type_parameter_constraints_clause ( ',' type_parameter_constraints_clause )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_parameter_constraints_clause_in_type_parameter_constraints_clauses4783);
            	type_parameter_constraints_clause649 = type_parameter_constraints_clause();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clause649.Tree);
            	// G:\\downloads\\antlr\\cs.g:677:38: ( ',' type_parameter_constraints_clause )*
            	do 
            	{
            	    int alt185 = 2;
            	    int LA185_0 = input.LA(1);

            	    if ( (LA185_0 == 89) )
            	    {
            	        alt185 = 1;
            	    }


            	    switch (alt185) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:677:39: ',' type_parameter_constraints_clause
            			    {
            			    	char_literal650=(IToken)Match(input,89,FOLLOW_89_in_type_parameter_constraints_clauses4788); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal650_tree = (object)adaptor.Create(char_literal650);
            			    		adaptor.AddChild(root_0, char_literal650_tree);
            			    	}
            			    	PushFollow(FOLLOW_type_parameter_constraints_clause_in_type_parameter_constraints_clauses4792);
            			    	type_parameter_constraints_clause651 = type_parameter_constraints_clause();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clause651.Tree);

            			    }
            			    break;

            			default:
            			    goto loop185;
            	    }
            	} while (true);

            	loop185:
            		;	// Stops C# compiler whining that label 'loop185' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 189, type_parameter_constraints_clauses_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_parameter_constraints_clauses"

    public class type_parameter_constraints_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_parameter_constraints_clause"
    // G:\\downloads\\antlr\\cs.g:678:1: type_parameter_constraints_clause : 'where' type_variable_name ':' type_parameter_constraint_list ;
    public csParser.type_parameter_constraints_clause_return type_parameter_constraints_clause() // throws RecognitionException [1]
    {   
        csParser.type_parameter_constraints_clause_return retval = new csParser.type_parameter_constraints_clause_return();
        retval.Start = input.LT(1);
        int type_parameter_constraints_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal652 = null;
        IToken char_literal654 = null;
        csParser.type_variable_name_return type_variable_name653 = default(csParser.type_variable_name_return);

        csParser.type_parameter_constraint_list_return type_parameter_constraint_list655 = default(csParser.type_parameter_constraint_list_return);


        object string_literal652_tree=null;
        object char_literal654_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 190) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:678:34: ( 'where' type_variable_name ':' type_parameter_constraint_list )
            // G:\\downloads\\antlr\\cs.g:679:2: 'where' type_variable_name ':' type_parameter_constraint_list
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal652=(IToken)Match(input,145,FOLLOW_145_in_type_parameter_constraints_clause4802); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal652_tree = (object)adaptor.Create(string_literal652);
            		adaptor.AddChild(root_0, string_literal652_tree);
            	}
            	PushFollow(FOLLOW_type_variable_name_in_type_parameter_constraints_clause4806);
            	type_variable_name653 = type_variable_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_variable_name653.Tree);
            	char_literal654=(IToken)Match(input,90,FOLLOW_90_in_type_parameter_constraints_clause4810); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal654_tree = (object)adaptor.Create(char_literal654);
            		adaptor.AddChild(root_0, char_literal654_tree);
            	}
            	PushFollow(FOLLOW_type_parameter_constraint_list_in_type_parameter_constraints_clause4814);
            	type_parameter_constraint_list655 = type_parameter_constraint_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraint_list655.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 190, type_parameter_constraints_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_parameter_constraints_clause"

    public class type_parameter_constraint_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_parameter_constraint_list"
    // G:\\downloads\\antlr\\cs.g:681:1: type_parameter_constraint_list : ( ( 'class' | 'struct' ) ( ',' secondary_constraint_list )? ( ',' constructor_constraint )? | secondary_constraint_list ( ',' constructor_constraint )? | constructor_constraint );
    public csParser.type_parameter_constraint_list_return type_parameter_constraint_list() // throws RecognitionException [1]
    {   
        csParser.type_parameter_constraint_list_return retval = new csParser.type_parameter_constraint_list_return();
        retval.Start = input.LT(1);
        int type_parameter_constraint_list_StartIndex = input.Index();
        object root_0 = null;

        IToken set656 = null;
        IToken char_literal657 = null;
        IToken char_literal659 = null;
        IToken char_literal662 = null;
        csParser.secondary_constraint_list_return secondary_constraint_list658 = default(csParser.secondary_constraint_list_return);

        csParser.constructor_constraint_return constructor_constraint660 = default(csParser.constructor_constraint_return);

        csParser.secondary_constraint_list_return secondary_constraint_list661 = default(csParser.secondary_constraint_list_return);

        csParser.constructor_constraint_return constructor_constraint663 = default(csParser.constructor_constraint_return);

        csParser.constructor_constraint_return constructor_constraint664 = default(csParser.constructor_constraint_return);


        object set656_tree=null;
        object char_literal657_tree=null;
        object char_literal659_tree=null;
        object char_literal662_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 191) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:681:31: ( ( 'class' | 'struct' ) ( ',' secondary_constraint_list )? ( ',' constructor_constraint )? | secondary_constraint_list ( ',' constructor_constraint )? | constructor_constraint )
            int alt189 = 3;
            switch ( input.LA(1) ) 
            {
            case 155:
            case 169:
            	{
                alt189 = 1;
                }
                break;
            case IDENTIFIER:
            case 65:
            case 132:
            case 133:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 170:
            case 177:
            case 178:
            case 195:
            case 202:
            	{
                alt189 = 2;
                }
                break;
            case 68:
            	{
                alt189 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d189s0 =
            	        new NoViableAltException("", 189, 0, input);

            	    throw nvae_d189s0;
            }

            switch (alt189) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:682:5: ( 'class' | 'struct' ) ( ',' secondary_constraint_list )? ( ',' constructor_constraint )?
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	set656 = (IToken)input.LT(1);
                    	if ( input.LA(1) == 155 || input.LA(1) == 169 ) 
                    	{
                    	    input.Consume();
                    	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set656));
                    	    state.errorRecovery = false;state.failed = false;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    MismatchedSetException mse = new MismatchedSetException(null,input);
                    	    throw mse;
                    	}

                    	// G:\\downloads\\antlr\\cs.g:682:28: ( ',' secondary_constraint_list )?
                    	int alt186 = 2;
                    	int LA186_0 = input.LA(1);

                    	if ( (LA186_0 == 89) )
                    	{
                    	    int LA186_1 = input.LA(2);

                    	    if ( (LA186_1 == 145) )
                    	    {
                    	        int LA186_3 = input.LA(3);

                    	        if ( (LA186_3 == DOT || LA186_3 == SEMI || LA186_3 == 62 || LA186_3 == 84 || LA186_3 == 89 || LA186_3 == 99) )
                    	        {
                    	            alt186 = 1;
                    	        }
                    	    }
                    	    else if ( (LA186_1 == IDENTIFIER || LA186_1 == 65 || (LA186_1 >= 132 && LA186_1 <= 133) || (LA186_1 >= 135 && LA186_1 <= 144) || (LA186_1 >= 146 && LA186_1 <= 148) || (LA186_1 >= 150 && LA186_1 <= 152) || LA186_1 == 154 || (LA186_1 >= 157 && LA186_1 <= 159) || LA186_1 == 170 || (LA186_1 >= 177 && LA186_1 <= 178) || LA186_1 == 195 || LA186_1 == 202) )
                    	    {
                    	        alt186 = 1;
                    	    }
                    	}
                    	switch (alt186) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:682:29: ',' secondary_constraint_list
                    	        {
                    	        	char_literal657=(IToken)Match(input,89,FOLLOW_89_in_type_parameter_constraint_list4888); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{char_literal657_tree = (object)adaptor.Create(char_literal657);
                    	        		adaptor.AddChild(root_0, char_literal657_tree);
                    	        	}
                    	        	PushFollow(FOLLOW_secondary_constraint_list_in_type_parameter_constraint_list4892);
                    	        	secondary_constraint_list658 = secondary_constraint_list();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint_list658.Tree);

                    	        }
                    	        break;

                    	}

                    	// G:\\downloads\\antlr\\cs.g:682:65: ( ',' constructor_constraint )?
                    	int alt187 = 2;
                    	int LA187_0 = input.LA(1);

                    	if ( (LA187_0 == 89) )
                    	{
                    	    int LA187_1 = input.LA(2);

                    	    if ( (LA187_1 == 68) )
                    	    {
                    	        alt187 = 1;
                    	    }
                    	}
                    	switch (alt187) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:682:66: ',' constructor_constraint
                    	        {
                    	        	char_literal659=(IToken)Match(input,89,FOLLOW_89_in_type_parameter_constraint_list4899); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{char_literal659_tree = (object)adaptor.Create(char_literal659);
                    	        		adaptor.AddChild(root_0, char_literal659_tree);
                    	        	}
                    	        	PushFollow(FOLLOW_constructor_constraint_in_type_parameter_constraint_list4903);
                    	        	constructor_constraint660 = constructor_constraint();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_constraint660.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:683:4: secondary_constraint_list ( ',' constructor_constraint )?
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_secondary_constraint_list_in_type_parameter_constraint_list4910);
                    	secondary_constraint_list661 = secondary_constraint_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint_list661.Tree);
                    	// G:\\downloads\\antlr\\cs.g:683:32: ( ',' constructor_constraint )?
                    	int alt188 = 2;
                    	int LA188_0 = input.LA(1);

                    	if ( (LA188_0 == 89) )
                    	{
                    	    int LA188_1 = input.LA(2);

                    	    if ( (LA188_1 == 68) )
                    	    {
                    	        alt188 = 1;
                    	    }
                    	}
                    	switch (alt188) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:683:33: ',' constructor_constraint
                    	        {
                    	        	char_literal662=(IToken)Match(input,89,FOLLOW_89_in_type_parameter_constraint_list4915); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{char_literal662_tree = (object)adaptor.Create(char_literal662);
                    	        		adaptor.AddChild(root_0, char_literal662_tree);
                    	        	}
                    	        	PushFollow(FOLLOW_constructor_constraint_in_type_parameter_constraint_list4919);
                    	        	constructor_constraint663 = constructor_constraint();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_constraint663.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:684:4: constructor_constraint
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_constructor_constraint_in_type_parameter_constraint_list4926);
                    	constructor_constraint664 = constructor_constraint();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_constraint664.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 191, type_parameter_constraint_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_parameter_constraint_list"

    public class secondary_constraint_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "secondary_constraint_list"
    // G:\\downloads\\antlr\\cs.g:689:1: secondary_constraint_list : secondary_constraint ( ',' secondary_constraint )* ;
    public csParser.secondary_constraint_list_return secondary_constraint_list() // throws RecognitionException [1]
    {   
        csParser.secondary_constraint_list_return retval = new csParser.secondary_constraint_list_return();
        retval.Start = input.LT(1);
        int secondary_constraint_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal666 = null;
        csParser.secondary_constraint_return secondary_constraint665 = default(csParser.secondary_constraint_return);

        csParser.secondary_constraint_return secondary_constraint667 = default(csParser.secondary_constraint_return);


        object char_literal666_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 192) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:689:26: ( secondary_constraint ( ',' secondary_constraint )* )
            // G:\\downloads\\antlr\\cs.g:690:2: secondary_constraint ( ',' secondary_constraint )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_secondary_constraint_in_secondary_constraint_list4938);
            	secondary_constraint665 = secondary_constraint();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint665.Tree);
            	// G:\\downloads\\antlr\\cs.g:690:23: ( ',' secondary_constraint )*
            	do 
            	{
            	    int alt190 = 2;
            	    int LA190_0 = input.LA(1);

            	    if ( (LA190_0 == 89) )
            	    {
            	        int LA190_1 = input.LA(2);

            	        if ( (LA190_1 == 145) )
            	        {
            	            int LA190_3 = input.LA(3);

            	            if ( (LA190_3 == DOT || LA190_3 == SEMI || LA190_3 == 62 || LA190_3 == 84 || LA190_3 == 89 || LA190_3 == 99) )
            	            {
            	                alt190 = 1;
            	            }


            	        }
            	        else if ( (LA190_1 == IDENTIFIER || LA190_1 == 65 || (LA190_1 >= 132 && LA190_1 <= 133) || (LA190_1 >= 135 && LA190_1 <= 144) || (LA190_1 >= 146 && LA190_1 <= 148) || (LA190_1 >= 150 && LA190_1 <= 152) || LA190_1 == 154 || (LA190_1 >= 157 && LA190_1 <= 159) || LA190_1 == 170 || (LA190_1 >= 177 && LA190_1 <= 178) || LA190_1 == 195 || LA190_1 == 202) )
            	        {
            	            alt190 = 1;
            	        }


            	    }


            	    switch (alt190) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:690:24: ',' secondary_constraint
            			    {
            			    	char_literal666=(IToken)Match(input,89,FOLLOW_89_in_secondary_constraint_list4941); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal666_tree = (object)adaptor.Create(char_literal666);
            			    		adaptor.AddChild(root_0, char_literal666_tree);
            			    	}
            			    	PushFollow(FOLLOW_secondary_constraint_in_secondary_constraint_list4943);
            			    	secondary_constraint667 = secondary_constraint();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, secondary_constraint667.Tree);

            			    }
            			    break;

            			default:
            			    goto loop190;
            	    }
            	} while (true);

            	loop190:
            		;	// Stops C# compiler whining that label 'loop190' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 192, secondary_constraint_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "secondary_constraint_list"

    public class secondary_constraint_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "secondary_constraint"
    // G:\\downloads\\antlr\\cs.g:691:1: secondary_constraint : type_name ;
    public csParser.secondary_constraint_return secondary_constraint() // throws RecognitionException [1]
    {   
        csParser.secondary_constraint_return retval = new csParser.secondary_constraint_return();
        retval.Start = input.LT(1);
        int secondary_constraint_StartIndex = input.Index();
        object root_0 = null;

        csParser.type_name_return type_name668 = default(csParser.type_name_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 193) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:691:21: ( type_name )
            // G:\\downloads\\antlr\\cs.g:692:2: type_name
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_type_name_in_secondary_constraint4953);
            	type_name668 = type_name();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name668.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 193, secondary_constraint_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "secondary_constraint"

    public class type_variable_name_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "type_variable_name"
    // G:\\downloads\\antlr\\cs.g:693:1: type_variable_name : identifier ;
    public csParser.type_variable_name_return type_variable_name() // throws RecognitionException [1]
    {   
        csParser.type_variable_name_return retval = new csParser.type_variable_name_return();
        retval.Start = input.LT(1);
        int type_variable_name_StartIndex = input.Index();
        object root_0 = null;

        csParser.identifier_return identifier669 = default(csParser.identifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 194) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:693:19: ( identifier )
            // G:\\downloads\\antlr\\cs.g:694:2: identifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_type_variable_name4963);
            	identifier669 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier669.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 194, type_variable_name_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "type_variable_name"

    public class constructor_constraint_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constructor_constraint"
    // G:\\downloads\\antlr\\cs.g:695:1: constructor_constraint : 'new' '(' ')' ;
    public csParser.constructor_constraint_return constructor_constraint() // throws RecognitionException [1]
    {   
        csParser.constructor_constraint_return retval = new csParser.constructor_constraint_return();
        retval.Start = input.LT(1);
        int constructor_constraint_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal670 = null;
        IToken char_literal671 = null;
        IToken char_literal672 = null;

        object string_literal670_tree=null;
        object char_literal671_tree=null;
        object char_literal672_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 195) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:695:23: ( 'new' '(' ')' )
            // G:\\downloads\\antlr\\cs.g:696:2: 'new' '(' ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal670=(IToken)Match(input,68,FOLLOW_68_in_constructor_constraint4971); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal670_tree = (object)adaptor.Create(string_literal670);
            		adaptor.AddChild(root_0, string_literal670_tree);
            	}
            	char_literal671=(IToken)Match(input,88,FOLLOW_88_in_constructor_constraint4975); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal671_tree = (object)adaptor.Create(char_literal671);
            		adaptor.AddChild(root_0, char_literal671_tree);
            	}
            	char_literal672=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_constructor_constraint4979); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal672_tree = (object)adaptor.Create(char_literal672);
            		adaptor.AddChild(root_0, char_literal672_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 195, constructor_constraint_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constructor_constraint"

    public class return_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "return_type"
    // G:\\downloads\\antlr\\cs.g:697:1: return_type : ( type | 'void' );
    public csParser.return_type_return return_type() // throws RecognitionException [1]
    {   
        csParser.return_type_return retval = new csParser.return_type_return();
        retval.Start = input.LT(1);
        int return_type_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal674 = null;
        csParser.type_return type673 = default(csParser.type_return);


        object string_literal674_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 196) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:697:12: ( type | 'void' )
            int alt191 = 2;
            int LA191_0 = input.LA(1);

            if ( (LA191_0 == IDENTIFIER || LA191_0 == 65 || (LA191_0 >= 132 && LA191_0 <= 133) || (LA191_0 >= 135 && LA191_0 <= 148) || (LA191_0 >= 150 && LA191_0 <= 152) || LA191_0 == 154 || (LA191_0 >= 157 && LA191_0 <= 168) || LA191_0 == 170 || (LA191_0 >= 177 && LA191_0 <= 178) || (LA191_0 >= 195 && LA191_0 <= 202)) )
            {
                alt191 = 1;
            }
            else if ( (LA191_0 == 82) )
            {
                int LA191_2 = input.LA(2);

                if ( (LA191_2 == IDENTIFIER || LA191_2 == 65 || (LA191_2 >= 132 && LA191_2 <= 133) || (LA191_2 >= 135 && LA191_2 <= 148) || (LA191_2 >= 150 && LA191_2 <= 152) || LA191_2 == 154 || (LA191_2 >= 157 && LA191_2 <= 159) || LA191_2 == 170 || (LA191_2 >= 177 && LA191_2 <= 178) || LA191_2 == 195 || LA191_2 == 202) )
                {
                    alt191 = 2;
                }
                else if ( (LA191_2 == 100) )
                {
                    alt191 = 1;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d191s2 =
                        new NoViableAltException("", 191, 2, input);

                    throw nvae_d191s2;
                }
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d191s0 =
                    new NoViableAltException("", 191, 0, input);

                throw nvae_d191s0;
            }
            switch (alt191) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:698:2: type
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_type_in_return_type4987);
                    	type673 = type();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type673.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:699:5: 'void'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal674=(IToken)Match(input,82,FOLLOW_82_in_return_type4993); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal674_tree = (object)adaptor.Create(string_literal674);
                    		adaptor.AddChild(root_0, string_literal674_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 196, return_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "return_type"

    public class formal_parameter_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "formal_parameter_list"
    // G:\\downloads\\antlr\\cs.g:700:1: formal_parameter_list : formal_parameter ( ',' formal_parameter )* ;
    public csParser.formal_parameter_list_return formal_parameter_list() // throws RecognitionException [1]
    {   
        csParser.formal_parameter_list_return retval = new csParser.formal_parameter_list_return();
        retval.Start = input.LT(1);
        int formal_parameter_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal676 = null;
        csParser.formal_parameter_return formal_parameter675 = default(csParser.formal_parameter_return);

        csParser.formal_parameter_return formal_parameter677 = default(csParser.formal_parameter_return);


        object char_literal676_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 197) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:700:22: ( formal_parameter ( ',' formal_parameter )* )
            // G:\\downloads\\antlr\\cs.g:701:2: formal_parameter ( ',' formal_parameter )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_formal_parameter_in_formal_parameter_list5000);
            	formal_parameter675 = formal_parameter();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter675.Tree);
            	// G:\\downloads\\antlr\\cs.g:701:19: ( ',' formal_parameter )*
            	do 
            	{
            	    int alt192 = 2;
            	    int LA192_0 = input.LA(1);

            	    if ( (LA192_0 == 89) )
            	    {
            	        alt192 = 1;
            	    }


            	    switch (alt192) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:701:20: ',' formal_parameter
            			    {
            			    	char_literal676=(IToken)Match(input,89,FOLLOW_89_in_formal_parameter_list5003); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal676_tree = (object)adaptor.Create(char_literal676);
            			    		adaptor.AddChild(root_0, char_literal676_tree);
            			    	}
            			    	PushFollow(FOLLOW_formal_parameter_in_formal_parameter_list5005);
            			    	formal_parameter677 = formal_parameter();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter677.Tree);

            			    }
            			    break;

            			default:
            			    goto loop192;
            	    }
            	} while (true);

            	loop192:
            		;	// Stops C# compiler whining that label 'loop192' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 197, formal_parameter_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "formal_parameter_list"

    public class formal_parameter_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "formal_parameter"
    // G:\\downloads\\antlr\\cs.g:702:1: formal_parameter : ( ( attributes )? ( fixed_parameter | parameter_array ) | '__arglist' );
    public csParser.formal_parameter_return formal_parameter() // throws RecognitionException [1]
    {   
        csParser.formal_parameter_return retval = new csParser.formal_parameter_return();
        retval.Start = input.LT(1);
        int formal_parameter_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal681 = null;
        csParser.attributes_return attributes678 = default(csParser.attributes_return);

        csParser.fixed_parameter_return fixed_parameter679 = default(csParser.fixed_parameter_return);

        csParser.parameter_array_return parameter_array680 = default(csParser.parameter_array_return);


        object string_literal681_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 198) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:702:17: ( ( attributes )? ( fixed_parameter | parameter_array ) | '__arglist' )
            int alt195 = 2;
            int LA195_0 = input.LA(1);

            if ( (LA195_0 == IDENTIFIER || LA195_0 == 65 || (LA195_0 >= 82 && LA195_0 <= 83) || LA195_0 == 86 || (LA195_0 >= 91 && LA195_0 <= 92) || (LA195_0 >= 132 && LA195_0 <= 133) || (LA195_0 >= 135 && LA195_0 <= 148) || (LA195_0 >= 150 && LA195_0 <= 152) || LA195_0 == 154 || (LA195_0 >= 157 && LA195_0 <= 168) || LA195_0 == 171 || (LA195_0 >= 177 && LA195_0 <= 178) || (LA195_0 >= 195 && LA195_0 <= 202)) )
            {
                alt195 = 1;
            }
            else if ( (LA195_0 == 170) )
            {
                int LA195_2 = input.LA(2);

                if ( (LA195_2 == IDENTIFIER || LA195_2 == DOT || LA195_2 == 65 || LA195_2 == 84 || LA195_2 == 86 || (LA195_2 >= 99 && LA195_2 <= 101) || (LA195_2 >= 132 && LA195_2 <= 133) || (LA195_2 >= 135 && LA195_2 <= 148) || (LA195_2 >= 150 && LA195_2 <= 152) || LA195_2 == 154 || (LA195_2 >= 157 && LA195_2 <= 159) || LA195_2 == 170 || (LA195_2 >= 177 && LA195_2 <= 178) || LA195_2 == 195 || LA195_2 == 202) )
                {
                    alt195 = 1;
                }
                else if ( (LA195_2 == RPAREN || LA195_2 == 87 || LA195_2 == 89) )
                {
                    alt195 = 2;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d195s2 =
                        new NoViableAltException("", 195, 2, input);

                    throw nvae_d195s2;
                }
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d195s0 =
                    new NoViableAltException("", 195, 0, input);

                throw nvae_d195s0;
            }
            switch (alt195) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:703:2: ( attributes )? ( fixed_parameter | parameter_array )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:703:2: ( attributes )?
                    	int alt193 = 2;
                    	int LA193_0 = input.LA(1);

                    	if ( (LA193_0 == 86) )
                    	{
                    	    alt193 = 1;
                    	}
                    	switch (alt193) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:703:2: attributes
                    	        {
                    	        	PushFollow(FOLLOW_attributes_in_formal_parameter5015);
                    	        	attributes678 = attributes();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes678.Tree);

                    	        }
                    	        break;

                    	}

                    	// G:\\downloads\\antlr\\cs.g:703:16: ( fixed_parameter | parameter_array )
                    	int alt194 = 2;
                    	int LA194_0 = input.LA(1);

                    	if ( (LA194_0 == IDENTIFIER || LA194_0 == 65 || (LA194_0 >= 82 && LA194_0 <= 83) || (LA194_0 >= 91 && LA194_0 <= 92) || (LA194_0 >= 132 && LA194_0 <= 133) || (LA194_0 >= 135 && LA194_0 <= 148) || (LA194_0 >= 150 && LA194_0 <= 152) || LA194_0 == 154 || (LA194_0 >= 157 && LA194_0 <= 168) || LA194_0 == 170 || (LA194_0 >= 177 && LA194_0 <= 178) || (LA194_0 >= 195 && LA194_0 <= 202)) )
                    	{
                    	    alt194 = 1;
                    	}
                    	else if ( (LA194_0 == 171) )
                    	{
                    	    alt194 = 2;
                    	}
                    	else 
                    	{
                    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    	    NoViableAltException nvae_d194s0 =
                    	        new NoViableAltException("", 194, 0, input);

                    	    throw nvae_d194s0;
                    	}
                    	switch (alt194) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:703:17: fixed_parameter
                    	        {
                    	        	PushFollow(FOLLOW_fixed_parameter_in_formal_parameter5021);
                    	        	fixed_parameter679 = fixed_parameter();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_parameter679.Tree);

                    	        }
                    	        break;
                    	    case 2 :
                    	        // G:\\downloads\\antlr\\cs.g:703:35: parameter_array
                    	        {
                    	        	PushFollow(FOLLOW_parameter_array_in_formal_parameter5025);
                    	        	parameter_array680 = parameter_array();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parameter_array680.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:704:4: '__arglist'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal681=(IToken)Match(input,170,FOLLOW_170_in_formal_parameter5032); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal681_tree = (object)adaptor.Create(string_literal681);
                    		adaptor.AddChild(root_0, string_literal681_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 198, formal_parameter_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "formal_parameter"

    public class fixed_parameters_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "fixed_parameters"
    // G:\\downloads\\antlr\\cs.g:705:1: fixed_parameters : fixed_parameter ( ',' fixed_parameter )* ;
    public csParser.fixed_parameters_return fixed_parameters() // throws RecognitionException [1]
    {   
        csParser.fixed_parameters_return retval = new csParser.fixed_parameters_return();
        retval.Start = input.LT(1);
        int fixed_parameters_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal683 = null;
        csParser.fixed_parameter_return fixed_parameter682 = default(csParser.fixed_parameter_return);

        csParser.fixed_parameter_return fixed_parameter684 = default(csParser.fixed_parameter_return);


        object char_literal683_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 199) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:705:17: ( fixed_parameter ( ',' fixed_parameter )* )
            // G:\\downloads\\antlr\\cs.g:706:2: fixed_parameter ( ',' fixed_parameter )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_fixed_parameter_in_fixed_parameters5040);
            	fixed_parameter682 = fixed_parameter();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_parameter682.Tree);
            	// G:\\downloads\\antlr\\cs.g:706:20: ( ',' fixed_parameter )*
            	do 
            	{
            	    int alt196 = 2;
            	    int LA196_0 = input.LA(1);

            	    if ( (LA196_0 == 89) )
            	    {
            	        alt196 = 1;
            	    }


            	    switch (alt196) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:706:21: ',' fixed_parameter
            			    {
            			    	char_literal683=(IToken)Match(input,89,FOLLOW_89_in_fixed_parameters5045); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal683_tree = (object)adaptor.Create(char_literal683);
            			    		adaptor.AddChild(root_0, char_literal683_tree);
            			    	}
            			    	PushFollow(FOLLOW_fixed_parameter_in_fixed_parameters5049);
            			    	fixed_parameter684 = fixed_parameter();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_parameter684.Tree);

            			    }
            			    break;

            			default:
            			    goto loop196;
            	    }
            	} while (true);

            	loop196:
            		;	// Stops C# compiler whining that label 'loop196' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 199, fixed_parameters_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "fixed_parameters"

    public class fixed_parameter_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "fixed_parameter"
    // G:\\downloads\\antlr\\cs.g:708:1: fixed_parameter : ( parameter_modifier )? type identifier ( default_argument )? ;
    public csParser.fixed_parameter_return fixed_parameter() // throws RecognitionException [1]
    {   
        csParser.fixed_parameter_return retval = new csParser.fixed_parameter_return();
        retval.Start = input.LT(1);
        int fixed_parameter_StartIndex = input.Index();
        object root_0 = null;

        csParser.parameter_modifier_return parameter_modifier685 = default(csParser.parameter_modifier_return);

        csParser.type_return type686 = default(csParser.type_return);

        csParser.identifier_return identifier687 = default(csParser.identifier_return);

        csParser.default_argument_return default_argument688 = default(csParser.default_argument_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 200) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:708:16: ( ( parameter_modifier )? type identifier ( default_argument )? )
            // G:\\downloads\\antlr\\cs.g:709:2: ( parameter_modifier )? type identifier ( default_argument )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:709:2: ( parameter_modifier )?
            	int alt197 = 2;
            	int LA197_0 = input.LA(1);

            	if ( (LA197_0 == 83 || (LA197_0 >= 91 && LA197_0 <= 92)) )
            	{
            	    alt197 = 1;
            	}
            	switch (alt197) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:709:2: parameter_modifier
            	        {
            	        	PushFollow(FOLLOW_parameter_modifier_in_fixed_parameter5060);
            	        	parameter_modifier685 = parameter_modifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, parameter_modifier685.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_type_in_fixed_parameter5065);
            	type686 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type686.Tree);
            	PushFollow(FOLLOW_identifier_in_fixed_parameter5069);
            	identifier687 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier687.Tree);
            	// G:\\downloads\\antlr\\cs.g:709:44: ( default_argument )?
            	int alt198 = 2;
            	int LA198_0 = input.LA(1);

            	if ( (LA198_0 == 66) )
            	{
            	    alt198 = 1;
            	}
            	switch (alt198) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:709:44: default_argument
            	        {
            	        	PushFollow(FOLLOW_default_argument_in_fixed_parameter5073);
            	        	default_argument688 = default_argument();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, default_argument688.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 200, fixed_parameter_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "fixed_parameter"

    public class default_argument_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "default_argument"
    // G:\\downloads\\antlr\\cs.g:711:1: default_argument : '=' expression ;
    public csParser.default_argument_return default_argument() // throws RecognitionException [1]
    {   
        csParser.default_argument_return retval = new csParser.default_argument_return();
        retval.Start = input.LT(1);
        int default_argument_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal689 = null;
        csParser.expression_return expression690 = default(csParser.expression_return);


        object char_literal689_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 201) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:711:17: ( '=' expression )
            // G:\\downloads\\antlr\\cs.g:712:2: '=' expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal689=(IToken)Match(input,66,FOLLOW_66_in_default_argument5083); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal689_tree = (object)adaptor.Create(char_literal689);
            		adaptor.AddChild(root_0, char_literal689_tree);
            	}
            	PushFollow(FOLLOW_expression_in_default_argument5085);
            	expression690 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression690.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 201, default_argument_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "default_argument"

    public class parameter_modifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "parameter_modifier"
    // G:\\downloads\\antlr\\cs.g:713:1: parameter_modifier : ( 'ref' | 'out' | 'this' );
    public csParser.parameter_modifier_return parameter_modifier() // throws RecognitionException [1]
    {   
        csParser.parameter_modifier_return retval = new csParser.parameter_modifier_return();
        retval.Start = input.LT(1);
        int parameter_modifier_StartIndex = input.Index();
        object root_0 = null;

        IToken set691 = null;

        object set691_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 202) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:713:19: ( 'ref' | 'out' | 'this' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set691 = (IToken)input.LT(1);
            	if ( input.LA(1) == 83 || (input.LA(1) >= 91 && input.LA(1) <= 92) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set691));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 202, parameter_modifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "parameter_modifier"

    public class parameter_array_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "parameter_array"
    // G:\\downloads\\antlr\\cs.g:715:1: parameter_array : 'params' type identifier ;
    public csParser.parameter_array_return parameter_array() // throws RecognitionException [1]
    {   
        csParser.parameter_array_return retval = new csParser.parameter_array_return();
        retval.Start = input.LT(1);
        int parameter_array_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal692 = null;
        csParser.type_return type693 = default(csParser.type_return);

        csParser.identifier_return identifier694 = default(csParser.identifier_return);


        object string_literal692_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 203) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:715:16: ( 'params' type identifier )
            // G:\\downloads\\antlr\\cs.g:716:2: 'params' type identifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal692=(IToken)Match(input,171,FOLLOW_171_in_parameter_array5108); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal692_tree = (object)adaptor.Create(string_literal692);
            		adaptor.AddChild(root_0, string_literal692_tree);
            	}
            	PushFollow(FOLLOW_type_in_parameter_array5112);
            	type693 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type693.Tree);
            	PushFollow(FOLLOW_identifier_in_parameter_array5116);
            	identifier694 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier694.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 203, parameter_array_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "parameter_array"

    public class interface_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_declaration"
    // G:\\downloads\\antlr\\cs.g:719:1: interface_declaration : 'interface' identifier ( variant_generic_parameter_list )? ( interface_base )? ( type_parameter_constraints_clauses )? interface_body ( ';' )? ;
    public csParser.interface_declaration_return interface_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_declaration_return retval = new csParser.interface_declaration_return();
        retval.Start = input.LT(1);
        int interface_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal695 = null;
        IToken char_literal701 = null;
        csParser.identifier_return identifier696 = default(csParser.identifier_return);

        csParser.variant_generic_parameter_list_return variant_generic_parameter_list697 = default(csParser.variant_generic_parameter_list_return);

        csParser.interface_base_return interface_base698 = default(csParser.interface_base_return);

        csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses699 = default(csParser.type_parameter_constraints_clauses_return);

        csParser.interface_body_return interface_body700 = default(csParser.interface_body_return);


        object string_literal695_tree=null;
        object char_literal701_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 204) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:719:22: ( 'interface' identifier ( variant_generic_parameter_list )? ( interface_base )? ( type_parameter_constraints_clauses )? interface_body ( ';' )? )
            // G:\\downloads\\antlr\\cs.g:720:2: 'interface' identifier ( variant_generic_parameter_list )? ( interface_base )? ( type_parameter_constraints_clauses )? interface_body ( ';' )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal695=(IToken)Match(input,172,FOLLOW_172_in_interface_declaration5126); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal695_tree = (object)adaptor.Create(string_literal695);
            		adaptor.AddChild(root_0, string_literal695_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_interface_declaration5130);
            	identifier696 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier696.Tree);
            	// G:\\downloads\\antlr\\cs.g:720:29: ( variant_generic_parameter_list )?
            	int alt199 = 2;
            	int LA199_0 = input.LA(1);

            	if ( (LA199_0 == 99) )
            	{
            	    alt199 = 1;
            	}
            	switch (alt199) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:720:29: variant_generic_parameter_list
            	        {
            	        	PushFollow(FOLLOW_variant_generic_parameter_list_in_interface_declaration5134);
            	        	variant_generic_parameter_list697 = variant_generic_parameter_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variant_generic_parameter_list697.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:721:6: ( interface_base )?
            	int alt200 = 2;
            	int LA200_0 = input.LA(1);

            	if ( (LA200_0 == 90) )
            	{
            	    alt200 = 1;
            	}
            	switch (alt200) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:721:6: interface_base
            	        {
            	        	PushFollow(FOLLOW_interface_base_in_interface_declaration5143);
            	        	interface_base698 = interface_base();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_base698.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:721:24: ( type_parameter_constraints_clauses )?
            	int alt201 = 2;
            	int LA201_0 = input.LA(1);

            	if ( (LA201_0 == 145) )
            	{
            	    alt201 = 1;
            	}
            	switch (alt201) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:721:24: type_parameter_constraints_clauses
            	        {
            	        	PushFollow(FOLLOW_type_parameter_constraints_clauses_in_interface_declaration5148);
            	        	type_parameter_constraints_clauses699 = type_parameter_constraints_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses699.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_interface_body_in_interface_declaration5153);
            	interface_body700 = interface_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_body700.Tree);
            	// G:\\downloads\\antlr\\cs.g:721:79: ( ';' )?
            	int alt202 = 2;
            	int LA202_0 = input.LA(1);

            	if ( (LA202_0 == SEMI) )
            	{
            	    alt202 = 1;
            	}
            	switch (alt202) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:721:79: ';'
            	        {
            	        	char_literal701=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_interface_declaration5157); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal701_tree = (object)adaptor.Create(char_literal701);
            	        		adaptor.AddChild(root_0, char_literal701_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 204, interface_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_declaration"

    public class interface_modifiers_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_modifiers"
    // G:\\downloads\\antlr\\cs.g:722:1: interface_modifiers : ( modifier )+ ;
    public csParser.interface_modifiers_return interface_modifiers() // throws RecognitionException [1]
    {   
        csParser.interface_modifiers_return retval = new csParser.interface_modifiers_return();
        retval.Start = input.LT(1);
        int interface_modifiers_StartIndex = input.Index();
        object root_0 = null;

        csParser.modifier_return modifier702 = default(csParser.modifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 205) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:722:20: ( ( modifier )+ )
            // G:\\downloads\\antlr\\cs.g:723:2: ( modifier )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:723:2: ( modifier )+
            	int cnt203 = 0;
            	do 
            	{
            	    int alt203 = 2;
            	    int LA203_0 = input.LA(1);

            	    if ( (LA203_0 == 64 || (LA203_0 >= 68 && LA203_0 <= 80)) )
            	    {
            	        alt203 = 1;
            	    }


            	    switch (alt203) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:723:2: modifier
            			    {
            			    	PushFollow(FOLLOW_modifier_in_interface_modifiers5167);
            			    	modifier702 = modifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier702.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt203 >= 1 ) goto loop203;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(203, input);
            		            throw eee;
            	    }
            	    cnt203++;
            	} while (true);

            	loop203:
            		;	// Stops C# compiler whinging that label 'loop203' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 205, interface_modifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_modifiers"

    public class interface_base_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_base"
    // G:\\downloads\\antlr\\cs.g:724:1: interface_base : ':' interface_type_list ;
    public csParser.interface_base_return interface_base() // throws RecognitionException [1]
    {   
        csParser.interface_base_return retval = new csParser.interface_base_return();
        retval.Start = input.LT(1);
        int interface_base_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal703 = null;
        csParser.interface_type_list_return interface_type_list704 = default(csParser.interface_type_list_return);


        object char_literal703_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 206) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:724:15: ( ':' interface_type_list )
            // G:\\downloads\\antlr\\cs.g:725:5: ':' interface_type_list
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal703=(IToken)Match(input,90,FOLLOW_90_in_interface_base5180); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal703_tree = (object)adaptor.Create(char_literal703);
            		adaptor.AddChild(root_0, char_literal703_tree);
            	}
            	PushFollow(FOLLOW_interface_type_list_in_interface_base5182);
            	interface_type_list704 = interface_type_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_type_list704.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 206, interface_base_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_base"

    public class interface_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_body"
    // G:\\downloads\\antlr\\cs.g:726:1: interface_body : '{' ( interface_member_declarations )? '}' ;
    public csParser.interface_body_return interface_body() // throws RecognitionException [1]
    {   
        csParser.interface_body_return retval = new csParser.interface_body_return();
        retval.Start = input.LT(1);
        int interface_body_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal705 = null;
        IToken char_literal707 = null;
        csParser.interface_member_declarations_return interface_member_declarations706 = default(csParser.interface_member_declarations_return);


        object char_literal705_tree=null;
        object char_literal707_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 207) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:726:15: ( '{' ( interface_member_declarations )? '}' )
            // G:\\downloads\\antlr\\cs.g:727:2: '{' ( interface_member_declarations )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal705=(IToken)Match(input,62,FOLLOW_62_in_interface_body5190); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal705_tree = (object)adaptor.Create(char_literal705);
            		adaptor.AddChild(root_0, char_literal705_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:727:8: ( interface_member_declarations )?
            	int alt204 = 2;
            	int LA204_0 = input.LA(1);

            	if ( (LA204_0 == IDENTIFIER || (LA204_0 >= 64 && LA204_0 <= 65) || (LA204_0 >= 68 && LA204_0 <= 80) || LA204_0 == 82 || LA204_0 == 86 || (LA204_0 >= 132 && LA204_0 <= 133) || (LA204_0 >= 135 && LA204_0 <= 152) || LA204_0 == 154 || (LA204_0 >= 157 && LA204_0 <= 168) || LA204_0 == 170 || (LA204_0 >= 177 && LA204_0 <= 178) || (LA204_0 >= 195 && LA204_0 <= 202)) )
            	{
            	    alt204 = 1;
            	}
            	switch (alt204) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:727:8: interface_member_declarations
            	        {
            	        	PushFollow(FOLLOW_interface_member_declarations_in_interface_body5194);
            	        	interface_member_declarations706 = interface_member_declarations();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_member_declarations706.Tree);

            	        }
            	        break;

            	}

            	char_literal707=(IToken)Match(input,63,FOLLOW_63_in_interface_body5199); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal707_tree = (object)adaptor.Create(char_literal707);
            		adaptor.AddChild(root_0, char_literal707_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 207, interface_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_body"

    public class interface_member_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_member_declarations"
    // G:\\downloads\\antlr\\cs.g:728:1: interface_member_declarations : ( interface_member_declaration )+ ;
    public csParser.interface_member_declarations_return interface_member_declarations() // throws RecognitionException [1]
    {   
        csParser.interface_member_declarations_return retval = new csParser.interface_member_declarations_return();
        retval.Start = input.LT(1);
        int interface_member_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.interface_member_declaration_return interface_member_declaration708 = default(csParser.interface_member_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 208) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:728:30: ( ( interface_member_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:729:2: ( interface_member_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:729:2: ( interface_member_declaration )+
            	int cnt205 = 0;
            	do 
            	{
            	    int alt205 = 2;
            	    int LA205_0 = input.LA(1);

            	    if ( (LA205_0 == IDENTIFIER || (LA205_0 >= 64 && LA205_0 <= 65) || (LA205_0 >= 68 && LA205_0 <= 80) || LA205_0 == 82 || LA205_0 == 86 || (LA205_0 >= 132 && LA205_0 <= 133) || (LA205_0 >= 135 && LA205_0 <= 152) || LA205_0 == 154 || (LA205_0 >= 157 && LA205_0 <= 168) || LA205_0 == 170 || (LA205_0 >= 177 && LA205_0 <= 178) || (LA205_0 >= 195 && LA205_0 <= 202)) )
            	    {
            	        alt205 = 1;
            	    }


            	    switch (alt205) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:729:2: interface_member_declaration
            			    {
            			    	PushFollow(FOLLOW_interface_member_declaration_in_interface_member_declarations5207);
            			    	interface_member_declaration708 = interface_member_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_member_declaration708.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt205 >= 1 ) goto loop205;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(205, input);
            		            throw eee;
            	    }
            	    cnt205++;
            	} while (true);

            	loop205:
            		;	// Stops C# compiler whinging that label 'loop205' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 208, interface_member_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_member_declarations"

    public class interface_member_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_member_declaration"
    // G:\\downloads\\antlr\\cs.g:730:1: interface_member_declaration : ( attributes )? ( modifiers )? ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) ) ;
    public csParser.interface_member_declaration_return interface_member_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_member_declaration_return retval = new csParser.interface_member_declaration_return();
        retval.Start = input.LT(1);
        int interface_member_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal711 = null;
        csParser.attributes_return attributes709 = default(csParser.attributes_return);

        csParser.modifiers_return modifiers710 = default(csParser.modifiers_return);

        csParser.interface_method_declaration_return interface_method_declaration712 = default(csParser.interface_method_declaration_return);

        csParser.interface_event_declaration_return interface_event_declaration713 = default(csParser.interface_event_declaration_return);

        csParser.type_return type714 = default(csParser.type_return);

        csParser.interface_method_declaration_return interface_method_declaration715 = default(csParser.interface_method_declaration_return);

        csParser.interface_property_declaration_return interface_property_declaration716 = default(csParser.interface_property_declaration_return);

        csParser.interface_indexer_declaration_return interface_indexer_declaration717 = default(csParser.interface_indexer_declaration_return);


        object string_literal711_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 209) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:730:29: ( ( attributes )? ( modifiers )? ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) ) )
            // G:\\downloads\\antlr\\cs.g:731:2: ( attributes )? ( modifiers )? ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:731:2: ( attributes )?
            	int alt206 = 2;
            	int LA206_0 = input.LA(1);

            	if ( (LA206_0 == 86) )
            	{
            	    alt206 = 1;
            	}
            	switch (alt206) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:731:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_interface_member_declaration5216);
            	        	attributes709 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes709.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:731:17: ( modifiers )?
            	int alt207 = 2;
            	int LA207_0 = input.LA(1);

            	if ( (LA207_0 == 64 || (LA207_0 >= 68 && LA207_0 <= 80)) )
            	{
            	    alt207 = 1;
            	}
            	switch (alt207) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:731:17: modifiers
            	        {
            	        	PushFollow(FOLLOW_modifiers_in_interface_member_declaration5222);
            	        	modifiers710 = modifiers();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers710.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:732:3: ( 'void' interface_method_declaration | interface_event_declaration | type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration ) )
            	int alt209 = 3;
            	switch ( input.LA(1) ) 
            	{
            	case 82:
            		{
            	    int LA209_1 = input.LA(2);

            	    if ( (LA209_1 == IDENTIFIER || LA209_1 == 65 || (LA209_1 >= 132 && LA209_1 <= 133) || (LA209_1 >= 135 && LA209_1 <= 148) || (LA209_1 >= 150 && LA209_1 <= 152) || LA209_1 == 154 || (LA209_1 >= 157 && LA209_1 <= 159) || LA209_1 == 170 || (LA209_1 >= 177 && LA209_1 <= 178) || LA209_1 == 195 || LA209_1 == 202) )
            	    {
            	        alt209 = 1;
            	    }
            	    else if ( (LA209_1 == 100) )
            	    {
            	        alt209 = 3;
            	    }
            	    else 
            	    {
            	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        NoViableAltException nvae_d209s1 =
            	            new NoViableAltException("", 209, 1, input);

            	        throw nvae_d209s1;
            	    }
            	    }
            	    break;
            	case 149:
            		{
            	    alt209 = 2;
            	    }
            	    break;
            	case IDENTIFIER:
            	case 65:
            	case 132:
            	case 133:
            	case 135:
            	case 136:
            	case 137:
            	case 138:
            	case 139:
            	case 140:
            	case 141:
            	case 142:
            	case 143:
            	case 144:
            	case 145:
            	case 146:
            	case 147:
            	case 148:
            	case 150:
            	case 151:
            	case 152:
            	case 154:
            	case 157:
            	case 158:
            	case 159:
            	case 160:
            	case 161:
            	case 162:
            	case 163:
            	case 164:
            	case 165:
            	case 166:
            	case 167:
            	case 168:
            	case 170:
            	case 177:
            	case 178:
            	case 195:
            	case 196:
            	case 197:
            	case 198:
            	case 199:
            	case 200:
            	case 201:
            	case 202:
            		{
            	    alt209 = 3;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		    NoViableAltException nvae_d209s0 =
            		        new NoViableAltException("", 209, 0, input);

            		    throw nvae_d209s0;
            	}

            	switch (alt209) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:732:4: 'void' interface_method_declaration
            	        {
            	        	string_literal711=(IToken)Match(input,82,FOLLOW_82_in_interface_member_declaration5228); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal711_tree = (object)adaptor.Create(string_literal711);
            	        		adaptor.AddChild(root_0, string_literal711_tree);
            	        	}
            	        	PushFollow(FOLLOW_interface_method_declaration_in_interface_member_declaration5232);
            	        	interface_method_declaration712 = interface_method_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_method_declaration712.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:733:5: interface_event_declaration
            	        {
            	        	PushFollow(FOLLOW_interface_event_declaration_in_interface_member_declaration5238);
            	        	interface_event_declaration713 = interface_event_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_event_declaration713.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // G:\\downloads\\antlr\\cs.g:734:5: type ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration )
            	        {
            	        	PushFollow(FOLLOW_type_in_interface_member_declaration5244);
            	        	type714 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type714.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:734:12: ( ( member_name '(' )=> interface_method_declaration | ( member_name '{' )=> interface_property_declaration | interface_indexer_declaration )
            	        	int alt208 = 3;
            	        	int LA208_0 = input.LA(1);

            	        	if ( (LA208_0 == IDENTIFIER || LA208_0 == 65 || (LA208_0 >= 132 && LA208_0 <= 133) || (LA208_0 >= 135 && LA208_0 <= 148) || (LA208_0 >= 150 && LA208_0 <= 152) || LA208_0 == 154 || (LA208_0 >= 157 && LA208_0 <= 159) || LA208_0 == 170 || (LA208_0 >= 177 && LA208_0 <= 178) || LA208_0 == 195 || LA208_0 == 202) )
            	        	{
            	        	    int LA208_1 = input.LA(2);

            	        	    if ( (LA208_1 == 99) && (synpred26_cs()) )
            	        	    {
            	        	        alt208 = 1;
            	        	    }
            	        	    else if ( (LA208_1 == 88) && (synpred26_cs()) )
            	        	    {
            	        	        alt208 = 1;
            	        	    }
            	        	    else if ( (LA208_1 == 62) && (synpred27_cs()) )
            	        	    {
            	        	        alt208 = 2;
            	        	    }
            	        	    else 
            	        	    {
            	        	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        	        NoViableAltException nvae_d208s1 =
            	        	            new NoViableAltException("", 208, 1, input);

            	        	        throw nvae_d208s1;
            	        	    }
            	        	}
            	        	else if ( (LA208_0 == 83) )
            	        	{
            	        	    alt208 = 3;
            	        	}
            	        	else 
            	        	{
            	        	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        	    NoViableAltException nvae_d208s0 =
            	        	        new NoViableAltException("", 208, 0, input);

            	        	    throw nvae_d208s0;
            	        	}
            	        	switch (alt208) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:734:14: ( member_name '(' )=> interface_method_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_interface_method_declaration_in_interface_member_declaration5260);
            	        	        	interface_method_declaration715 = interface_method_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_method_declaration715.Tree);

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:735:14: ( member_name '{' )=> interface_property_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_interface_property_declaration_in_interface_member_declaration5285);
            	        	        	interface_property_declaration716 = interface_property_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_property_declaration716.Tree);

            	        	        }
            	        	        break;
            	        	    case 3 :
            	        	        // G:\\downloads\\antlr\\cs.g:736:8: interface_indexer_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_interface_indexer_declaration_in_interface_member_declaration5295);
            	        	        	interface_indexer_declaration717 = interface_indexer_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_indexer_declaration717.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 209, interface_member_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_member_declaration"

    public class interface_property_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_property_declaration"
    // G:\\downloads\\antlr\\cs.g:739:1: interface_property_declaration : identifier '{' interface_accessor_declarations '}' ;
    public csParser.interface_property_declaration_return interface_property_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_property_declaration_return retval = new csParser.interface_property_declaration_return();
        retval.Start = input.LT(1);
        int interface_property_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal719 = null;
        IToken char_literal721 = null;
        csParser.identifier_return identifier718 = default(csParser.identifier_return);

        csParser.interface_accessor_declarations_return interface_accessor_declarations720 = default(csParser.interface_accessor_declarations_return);


        object char_literal719_tree=null;
        object char_literal721_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 210) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:739:31: ( identifier '{' interface_accessor_declarations '}' )
            // G:\\downloads\\antlr\\cs.g:740:2: identifier '{' interface_accessor_declarations '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_interface_property_declaration5312);
            	identifier718 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier718.Tree);
            	char_literal719=(IToken)Match(input,62,FOLLOW_62_in_interface_property_declaration5316); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal719_tree = (object)adaptor.Create(char_literal719);
            		adaptor.AddChild(root_0, char_literal719_tree);
            	}
            	PushFollow(FOLLOW_interface_accessor_declarations_in_interface_property_declaration5320);
            	interface_accessor_declarations720 = interface_accessor_declarations();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_accessor_declarations720.Tree);
            	char_literal721=(IToken)Match(input,63,FOLLOW_63_in_interface_property_declaration5324); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal721_tree = (object)adaptor.Create(char_literal721);
            		adaptor.AddChild(root_0, char_literal721_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 210, interface_property_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_property_declaration"

    public class interface_method_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_method_declaration"
    // G:\\downloads\\antlr\\cs.g:741:1: interface_method_declaration : identifier ( generic_argument_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' ;
    public csParser.interface_method_declaration_return interface_method_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_method_declaration_return retval = new csParser.interface_method_declaration_return();
        retval.Start = input.LT(1);
        int interface_method_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal724 = null;
        IToken char_literal726 = null;
        IToken char_literal728 = null;
        csParser.identifier_return identifier722 = default(csParser.identifier_return);

        csParser.generic_argument_list_return generic_argument_list723 = default(csParser.generic_argument_list_return);

        csParser.formal_parameter_list_return formal_parameter_list725 = default(csParser.formal_parameter_list_return);

        csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses727 = default(csParser.type_parameter_constraints_clauses_return);


        object char_literal724_tree=null;
        object char_literal726_tree=null;
        object char_literal728_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 211) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:741:29: ( identifier ( generic_argument_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';' )
            // G:\\downloads\\antlr\\cs.g:742:2: identifier ( generic_argument_list )? '(' ( formal_parameter_list )? ')' ( type_parameter_constraints_clauses )? ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_interface_method_declaration5332);
            	identifier722 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier722.Tree);
            	// G:\\downloads\\antlr\\cs.g:742:15: ( generic_argument_list )?
            	int alt210 = 2;
            	int LA210_0 = input.LA(1);

            	if ( (LA210_0 == 99) )
            	{
            	    alt210 = 1;
            	}
            	switch (alt210) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:742:15: generic_argument_list
            	        {
            	        	PushFollow(FOLLOW_generic_argument_list_in_interface_method_declaration5336);
            	        	generic_argument_list723 = generic_argument_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list723.Tree);

            	        }
            	        break;

            	}

            	char_literal724=(IToken)Match(input,88,FOLLOW_88_in_interface_method_declaration5344); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal724_tree = (object)adaptor.Create(char_literal724);
            		adaptor.AddChild(root_0, char_literal724_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:743:12: ( formal_parameter_list )?
            	int alt211 = 2;
            	int LA211_0 = input.LA(1);

            	if ( (LA211_0 == IDENTIFIER || LA211_0 == 65 || (LA211_0 >= 82 && LA211_0 <= 83) || LA211_0 == 86 || (LA211_0 >= 91 && LA211_0 <= 92) || (LA211_0 >= 132 && LA211_0 <= 133) || (LA211_0 >= 135 && LA211_0 <= 148) || (LA211_0 >= 150 && LA211_0 <= 152) || LA211_0 == 154 || (LA211_0 >= 157 && LA211_0 <= 168) || (LA211_0 >= 170 && LA211_0 <= 171) || (LA211_0 >= 177 && LA211_0 <= 178) || (LA211_0 >= 195 && LA211_0 <= 202)) )
            	{
            	    alt211 = 1;
            	}
            	switch (alt211) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:743:12: formal_parameter_list
            	        {
            	        	PushFollow(FOLLOW_formal_parameter_list_in_interface_method_declaration5348);
            	        	formal_parameter_list725 = formal_parameter_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list725.Tree);

            	        }
            	        break;

            	}

            	char_literal726=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_interface_method_declaration5353); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal726_tree = (object)adaptor.Create(char_literal726);
            		adaptor.AddChild(root_0, char_literal726_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:743:43: ( type_parameter_constraints_clauses )?
            	int alt212 = 2;
            	int LA212_0 = input.LA(1);

            	if ( (LA212_0 == 145) )
            	{
            	    alt212 = 1;
            	}
            	switch (alt212) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:743:43: type_parameter_constraints_clauses
            	        {
            	        	PushFollow(FOLLOW_type_parameter_constraints_clauses_in_interface_method_declaration5357);
            	        	type_parameter_constraints_clauses727 = type_parameter_constraints_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses727.Tree);

            	        }
            	        break;

            	}

            	char_literal728=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_interface_method_declaration5362); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal728_tree = (object)adaptor.Create(char_literal728);
            		adaptor.AddChild(root_0, char_literal728_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 211, interface_method_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_method_declaration"

    public class interface_event_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_event_declaration"
    // G:\\downloads\\antlr\\cs.g:744:1: interface_event_declaration : 'event' type identifier ';' ;
    public csParser.interface_event_declaration_return interface_event_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_event_declaration_return retval = new csParser.interface_event_declaration_return();
        retval.Start = input.LT(1);
        int interface_event_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal729 = null;
        IToken char_literal732 = null;
        csParser.type_return type730 = default(csParser.type_return);

        csParser.identifier_return identifier731 = default(csParser.identifier_return);


        object string_literal729_tree=null;
        object char_literal732_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 212) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:744:28: ( 'event' type identifier ';' )
            // G:\\downloads\\antlr\\cs.g:746:2: 'event' type identifier ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal729=(IToken)Match(input,149,FOLLOW_149_in_interface_event_declaration5373); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal729_tree = (object)adaptor.Create(string_literal729);
            		adaptor.AddChild(root_0, string_literal729_tree);
            	}
            	PushFollow(FOLLOW_type_in_interface_event_declaration5377);
            	type730 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type730.Tree);
            	PushFollow(FOLLOW_identifier_in_interface_event_declaration5381);
            	identifier731 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier731.Tree);
            	char_literal732=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_interface_event_declaration5385); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal732_tree = (object)adaptor.Create(char_literal732);
            		adaptor.AddChild(root_0, char_literal732_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 212, interface_event_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_event_declaration"

    public class interface_indexer_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_indexer_declaration"
    // G:\\downloads\\antlr\\cs.g:747:1: interface_indexer_declaration : 'this' '[' formal_parameter_list ']' '{' interface_accessor_declarations '}' ;
    public csParser.interface_indexer_declaration_return interface_indexer_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_indexer_declaration_return retval = new csParser.interface_indexer_declaration_return();
        retval.Start = input.LT(1);
        int interface_indexer_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal733 = null;
        IToken char_literal734 = null;
        IToken char_literal736 = null;
        IToken char_literal737 = null;
        IToken char_literal739 = null;
        csParser.formal_parameter_list_return formal_parameter_list735 = default(csParser.formal_parameter_list_return);

        csParser.interface_accessor_declarations_return interface_accessor_declarations738 = default(csParser.interface_accessor_declarations_return);


        object string_literal733_tree=null;
        object char_literal734_tree=null;
        object char_literal736_tree=null;
        object char_literal737_tree=null;
        object char_literal739_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 213) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:747:30: ( 'this' '[' formal_parameter_list ']' '{' interface_accessor_declarations '}' )
            // G:\\downloads\\antlr\\cs.g:749:2: 'this' '[' formal_parameter_list ']' '{' interface_accessor_declarations '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal733=(IToken)Match(input,83,FOLLOW_83_in_interface_indexer_declaration5397); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal733_tree = (object)adaptor.Create(string_literal733);
            		adaptor.AddChild(root_0, string_literal733_tree);
            	}
            	char_literal734=(IToken)Match(input,86,FOLLOW_86_in_interface_indexer_declaration5401); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal734_tree = (object)adaptor.Create(char_literal734);
            		adaptor.AddChild(root_0, char_literal734_tree);
            	}
            	PushFollow(FOLLOW_formal_parameter_list_in_interface_indexer_declaration5405);
            	formal_parameter_list735 = formal_parameter_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list735.Tree);
            	char_literal736=(IToken)Match(input,87,FOLLOW_87_in_interface_indexer_declaration5409); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal736_tree = (object)adaptor.Create(char_literal736);
            		adaptor.AddChild(root_0, char_literal736_tree);
            	}
            	char_literal737=(IToken)Match(input,62,FOLLOW_62_in_interface_indexer_declaration5413); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal737_tree = (object)adaptor.Create(char_literal737);
            		adaptor.AddChild(root_0, char_literal737_tree);
            	}
            	PushFollow(FOLLOW_interface_accessor_declarations_in_interface_indexer_declaration5417);
            	interface_accessor_declarations738 = interface_accessor_declarations();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_accessor_declarations738.Tree);
            	char_literal739=(IToken)Match(input,63,FOLLOW_63_in_interface_indexer_declaration5421); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal739_tree = (object)adaptor.Create(char_literal739);
            		adaptor.AddChild(root_0, char_literal739_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 213, interface_indexer_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_indexer_declaration"

    public class interface_accessor_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_accessor_declarations"
    // G:\\downloads\\antlr\\cs.g:750:1: interface_accessor_declarations : ( attributes )? ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? ) ;
    public csParser.interface_accessor_declarations_return interface_accessor_declarations() // throws RecognitionException [1]
    {   
        csParser.interface_accessor_declarations_return retval = new csParser.interface_accessor_declarations_return();
        retval.Start = input.LT(1);
        int interface_accessor_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.attributes_return attributes740 = default(csParser.attributes_return);

        csParser.interface_get_accessor_declaration_return interface_get_accessor_declaration741 = default(csParser.interface_get_accessor_declaration_return);

        csParser.attributes_return attributes742 = default(csParser.attributes_return);

        csParser.interface_set_accessor_declaration_return interface_set_accessor_declaration743 = default(csParser.interface_set_accessor_declaration_return);

        csParser.interface_set_accessor_declaration_return interface_set_accessor_declaration744 = default(csParser.interface_set_accessor_declaration_return);

        csParser.attributes_return attributes745 = default(csParser.attributes_return);

        csParser.interface_get_accessor_declaration_return interface_get_accessor_declaration746 = default(csParser.interface_get_accessor_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 214) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:750:32: ( ( attributes )? ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? ) )
            // G:\\downloads\\antlr\\cs.g:751:2: ( attributes )? ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:751:2: ( attributes )?
            	int alt213 = 2;
            	int LA213_0 = input.LA(1);

            	if ( (LA213_0 == 86) )
            	{
            	    alt213 = 1;
            	}
            	switch (alt213) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:751:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_interface_accessor_declarations5429);
            	        	attributes740 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes740.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:752:3: ( interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )? | interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )? )
            	int alt218 = 2;
            	int LA218_0 = input.LA(1);

            	if ( (LA218_0 == 156) )
            	{
            	    alt218 = 1;
            	}
            	else if ( (LA218_0 == 157) )
            	{
            	    alt218 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d218s0 =
            	        new NoViableAltException("", 218, 0, input);

            	    throw nvae_d218s0;
            	}
            	switch (alt218) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:752:4: interface_get_accessor_declaration ( attributes )? ( interface_set_accessor_declaration )?
            	        {
            	        	PushFollow(FOLLOW_interface_get_accessor_declaration_in_interface_accessor_declarations5438);
            	        	interface_get_accessor_declaration741 = interface_get_accessor_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_get_accessor_declaration741.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:752:41: ( attributes )?
            	        	int alt214 = 2;
            	        	int LA214_0 = input.LA(1);

            	        	if ( (LA214_0 == 86) )
            	        	{
            	        	    alt214 = 1;
            	        	}
            	        	switch (alt214) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:752:41: attributes
            	        	        {
            	        	        	PushFollow(FOLLOW_attributes_in_interface_accessor_declarations5442);
            	        	        	attributes742 = attributes();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes742.Tree);

            	        	        }
            	        	        break;

            	        	}

            	        	// G:\\downloads\\antlr\\cs.g:752:55: ( interface_set_accessor_declaration )?
            	        	int alt215 = 2;
            	        	int LA215_0 = input.LA(1);

            	        	if ( (LA215_0 == 157) )
            	        	{
            	        	    alt215 = 1;
            	        	}
            	        	switch (alt215) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:752:55: interface_set_accessor_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_interface_set_accessor_declaration_in_interface_accessor_declarations5447);
            	        	        	interface_set_accessor_declaration743 = interface_set_accessor_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_set_accessor_declaration743.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:753:5: interface_set_accessor_declaration ( attributes )? ( interface_get_accessor_declaration )?
            	        {
            	        	PushFollow(FOLLOW_interface_set_accessor_declaration_in_interface_accessor_declarations5454);
            	        	interface_set_accessor_declaration744 = interface_set_accessor_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_set_accessor_declaration744.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:753:42: ( attributes )?
            	        	int alt216 = 2;
            	        	int LA216_0 = input.LA(1);

            	        	if ( (LA216_0 == 86) )
            	        	{
            	        	    alt216 = 1;
            	        	}
            	        	switch (alt216) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:753:42: attributes
            	        	        {
            	        	        	PushFollow(FOLLOW_attributes_in_interface_accessor_declarations5458);
            	        	        	attributes745 = attributes();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes745.Tree);

            	        	        }
            	        	        break;

            	        	}

            	        	// G:\\downloads\\antlr\\cs.g:753:56: ( interface_get_accessor_declaration )?
            	        	int alt217 = 2;
            	        	int LA217_0 = input.LA(1);

            	        	if ( (LA217_0 == 156) )
            	        	{
            	        	    alt217 = 1;
            	        	}
            	        	switch (alt217) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:753:56: interface_get_accessor_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_interface_get_accessor_declaration_in_interface_accessor_declarations5463);
            	        	        	interface_get_accessor_declaration746 = interface_get_accessor_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_get_accessor_declaration746.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 214, interface_accessor_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_accessor_declarations"

    public class interface_get_accessor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_get_accessor_declaration"
    // G:\\downloads\\antlr\\cs.g:754:1: interface_get_accessor_declaration : 'get' ';' ;
    public csParser.interface_get_accessor_declaration_return interface_get_accessor_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_get_accessor_declaration_return retval = new csParser.interface_get_accessor_declaration_return();
        retval.Start = input.LT(1);
        int interface_get_accessor_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal747 = null;
        IToken char_literal748 = null;

        object string_literal747_tree=null;
        object char_literal748_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 215) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:754:35: ( 'get' ';' )
            // G:\\downloads\\antlr\\cs.g:755:2: 'get' ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal747=(IToken)Match(input,156,FOLLOW_156_in_interface_get_accessor_declaration5473); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal747_tree = (object)adaptor.Create(string_literal747);
            		adaptor.AddChild(root_0, string_literal747_tree);
            	}
            	char_literal748=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_interface_get_accessor_declaration5477); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal748_tree = (object)adaptor.Create(char_literal748);
            		adaptor.AddChild(root_0, char_literal748_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 215, interface_get_accessor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_get_accessor_declaration"

    public class interface_set_accessor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "interface_set_accessor_declaration"
    // G:\\downloads\\antlr\\cs.g:756:1: interface_set_accessor_declaration : 'set' ';' ;
    public csParser.interface_set_accessor_declaration_return interface_set_accessor_declaration() // throws RecognitionException [1]
    {   
        csParser.interface_set_accessor_declaration_return retval = new csParser.interface_set_accessor_declaration_return();
        retval.Start = input.LT(1);
        int interface_set_accessor_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal749 = null;
        IToken char_literal750 = null;

        object string_literal749_tree=null;
        object char_literal750_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 216) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:756:35: ( 'set' ';' )
            // G:\\downloads\\antlr\\cs.g:757:2: 'set' ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal749=(IToken)Match(input,157,FOLLOW_157_in_interface_set_accessor_declaration5487); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal749_tree = (object)adaptor.Create(string_literal749);
            		adaptor.AddChild(root_0, string_literal749_tree);
            	}
            	char_literal750=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_interface_set_accessor_declaration5491); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal750_tree = (object)adaptor.Create(char_literal750);
            		adaptor.AddChild(root_0, char_literal750_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 216, interface_set_accessor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "interface_set_accessor_declaration"

    public class method_modifiers_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "method_modifiers"
    // G:\\downloads\\antlr\\cs.g:758:1: method_modifiers : ( modifier )+ ;
    public csParser.method_modifiers_return method_modifiers() // throws RecognitionException [1]
    {   
        csParser.method_modifiers_return retval = new csParser.method_modifiers_return();
        retval.Start = input.LT(1);
        int method_modifiers_StartIndex = input.Index();
        object root_0 = null;

        csParser.modifier_return modifier751 = default(csParser.modifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 217) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:758:17: ( ( modifier )+ )
            // G:\\downloads\\antlr\\cs.g:759:2: ( modifier )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:759:2: ( modifier )+
            	int cnt219 = 0;
            	do 
            	{
            	    int alt219 = 2;
            	    int LA219_0 = input.LA(1);

            	    if ( (LA219_0 == 64 || (LA219_0 >= 68 && LA219_0 <= 80)) )
            	    {
            	        alt219 = 1;
            	    }


            	    switch (alt219) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:759:2: modifier
            			    {
            			    	PushFollow(FOLLOW_modifier_in_method_modifiers5501);
            			    	modifier751 = modifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifier751.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt219 >= 1 ) goto loop219;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(219, input);
            		            throw eee;
            	    }
            	    cnt219++;
            	} while (true);

            	loop219:
            		;	// Stops C# compiler whinging that label 'loop219' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 217, method_modifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "method_modifiers"

    public class struct_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "struct_declaration"
    // G:\\downloads\\antlr\\cs.g:762:1: struct_declaration : 'struct' type_or_generic ( struct_interfaces )? ( type_parameter_constraints_clauses )? struct_body ( ';' )? ;
    public csParser.struct_declaration_return struct_declaration() // throws RecognitionException [1]
    {   
        csParser.struct_declaration_return retval = new csParser.struct_declaration_return();
        retval.Start = input.LT(1);
        int struct_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal752 = null;
        IToken char_literal757 = null;
        csParser.type_or_generic_return type_or_generic753 = default(csParser.type_or_generic_return);

        csParser.struct_interfaces_return struct_interfaces754 = default(csParser.struct_interfaces_return);

        csParser.type_parameter_constraints_clauses_return type_parameter_constraints_clauses755 = default(csParser.type_parameter_constraints_clauses_return);

        csParser.struct_body_return struct_body756 = default(csParser.struct_body_return);


        object string_literal752_tree=null;
        object char_literal757_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 218) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:762:19: ( 'struct' type_or_generic ( struct_interfaces )? ( type_parameter_constraints_clauses )? struct_body ( ';' )? )
            // G:\\downloads\\antlr\\cs.g:763:2: 'struct' type_or_generic ( struct_interfaces )? ( type_parameter_constraints_clauses )? struct_body ( ';' )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal752=(IToken)Match(input,169,FOLLOW_169_in_struct_declaration5513); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal752_tree = (object)adaptor.Create(string_literal752);
            		adaptor.AddChild(root_0, string_literal752_tree);
            	}
            	PushFollow(FOLLOW_type_or_generic_in_struct_declaration5517);
            	type_or_generic753 = type_or_generic();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_or_generic753.Tree);
            	// G:\\downloads\\antlr\\cs.g:763:31: ( struct_interfaces )?
            	int alt220 = 2;
            	int LA220_0 = input.LA(1);

            	if ( (LA220_0 == 90) )
            	{
            	    alt220 = 1;
            	}
            	switch (alt220) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:763:31: struct_interfaces
            	        {
            	        	PushFollow(FOLLOW_struct_interfaces_in_struct_declaration5521);
            	        	struct_interfaces754 = struct_interfaces();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_interfaces754.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:763:52: ( type_parameter_constraints_clauses )?
            	int alt221 = 2;
            	int LA221_0 = input.LA(1);

            	if ( (LA221_0 == 145) )
            	{
            	    alt221 = 1;
            	}
            	switch (alt221) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:763:52: type_parameter_constraints_clauses
            	        {
            	        	PushFollow(FOLLOW_type_parameter_constraints_clauses_in_struct_declaration5526);
            	        	type_parameter_constraints_clauses755 = type_parameter_constraints_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_parameter_constraints_clauses755.Tree);

            	        }
            	        break;

            	}

            	PushFollow(FOLLOW_struct_body_in_struct_declaration5531);
            	struct_body756 = struct_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_body756.Tree);
            	// G:\\downloads\\antlr\\cs.g:763:104: ( ';' )?
            	int alt222 = 2;
            	int LA222_0 = input.LA(1);

            	if ( (LA222_0 == SEMI) )
            	{
            	    alt222 = 1;
            	}
            	switch (alt222) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:763:104: ';'
            	        {
            	        	char_literal757=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_struct_declaration5535); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal757_tree = (object)adaptor.Create(char_literal757);
            	        		adaptor.AddChild(root_0, char_literal757_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 218, struct_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "struct_declaration"

    public class struct_modifiers_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "struct_modifiers"
    // G:\\downloads\\antlr\\cs.g:764:1: struct_modifiers : ( struct_modifier )+ ;
    public csParser.struct_modifiers_return struct_modifiers() // throws RecognitionException [1]
    {   
        csParser.struct_modifiers_return retval = new csParser.struct_modifiers_return();
        retval.Start = input.LT(1);
        int struct_modifiers_StartIndex = input.Index();
        object root_0 = null;

        csParser.struct_modifier_return struct_modifier758 = default(csParser.struct_modifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 219) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:764:17: ( ( struct_modifier )+ )
            // G:\\downloads\\antlr\\cs.g:765:2: ( struct_modifier )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:765:2: ( struct_modifier )+
            	int cnt223 = 0;
            	do 
            	{
            	    int alt223 = 2;
            	    int LA223_0 = input.LA(1);

            	    if ( ((LA223_0 >= 68 && LA223_0 <= 73)) )
            	    {
            	        alt223 = 1;
            	    }


            	    switch (alt223) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:765:2: struct_modifier
            			    {
            			    	PushFollow(FOLLOW_struct_modifier_in_struct_modifiers5544);
            			    	struct_modifier758 = struct_modifier();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_modifier758.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt223 >= 1 ) goto loop223;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(223, input);
            		            throw eee;
            	    }
            	    cnt223++;
            	} while (true);

            	loop223:
            		;	// Stops C# compiler whinging that label 'loop223' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 219, struct_modifiers_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "struct_modifiers"

    public class struct_modifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "struct_modifier"
    // G:\\downloads\\antlr\\cs.g:766:1: struct_modifier : ( 'new' | 'public' | 'protected' | 'internal' | 'private' | 'unsafe' );
    public csParser.struct_modifier_return struct_modifier() // throws RecognitionException [1]
    {   
        csParser.struct_modifier_return retval = new csParser.struct_modifier_return();
        retval.Start = input.LT(1);
        int struct_modifier_StartIndex = input.Index();
        object root_0 = null;

        IToken set759 = null;

        object set759_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 220) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:766:16: ( 'new' | 'public' | 'protected' | 'internal' | 'private' | 'unsafe' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set759 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 68 && input.LA(1) <= 73) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set759));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 220, struct_modifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "struct_modifier"

    public class struct_interfaces_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "struct_interfaces"
    // G:\\downloads\\antlr\\cs.g:768:1: struct_interfaces : ':' interface_type_list ;
    public csParser.struct_interfaces_return struct_interfaces() // throws RecognitionException [1]
    {   
        csParser.struct_interfaces_return retval = new csParser.struct_interfaces_return();
        retval.Start = input.LT(1);
        int struct_interfaces_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal760 = null;
        csParser.interface_type_list_return interface_type_list761 = default(csParser.interface_type_list_return);


        object char_literal760_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 221) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:768:18: ( ':' interface_type_list )
            // G:\\downloads\\antlr\\cs.g:769:2: ':' interface_type_list
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal760=(IToken)Match(input,90,FOLLOW_90_in_struct_interfaces5581); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal760_tree = (object)adaptor.Create(char_literal760);
            		adaptor.AddChild(root_0, char_literal760_tree);
            	}
            	PushFollow(FOLLOW_interface_type_list_in_struct_interfaces5585);
            	interface_type_list761 = interface_type_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_type_list761.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 221, struct_interfaces_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "struct_interfaces"

    public class struct_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "struct_body"
    // G:\\downloads\\antlr\\cs.g:770:1: struct_body : '{' ( struct_member_declarations )? '}' ;
    public csParser.struct_body_return struct_body() // throws RecognitionException [1]
    {   
        csParser.struct_body_return retval = new csParser.struct_body_return();
        retval.Start = input.LT(1);
        int struct_body_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal762 = null;
        IToken char_literal764 = null;
        csParser.struct_member_declarations_return struct_member_declarations763 = default(csParser.struct_member_declarations_return);


        object char_literal762_tree=null;
        object char_literal764_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 222) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:770:12: ( '{' ( struct_member_declarations )? '}' )
            // G:\\downloads\\antlr\\cs.g:771:2: '{' ( struct_member_declarations )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal762=(IToken)Match(input,62,FOLLOW_62_in_struct_body5592); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal762_tree = (object)adaptor.Create(char_literal762);
            		adaptor.AddChild(root_0, char_literal762_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:771:8: ( struct_member_declarations )?
            	int alt224 = 2;
            	int LA224_0 = input.LA(1);

            	if ( (LA224_0 == IDENTIFIER || LA224_0 == ENUM || (LA224_0 >= 64 && LA224_0 <= 65) || (LA224_0 >= 67 && LA224_0 <= 82) || LA224_0 == 86 || LA224_0 == 97 || (LA224_0 >= 132 && LA224_0 <= 133) || (LA224_0 >= 135 && LA224_0 <= 152) || (LA224_0 >= 154 && LA224_0 <= 155) || (LA224_0 >= 157 && LA224_0 <= 170) || LA224_0 == 172 || (LA224_0 >= 174 && LA224_0 <= 175) || (LA224_0 >= 177 && LA224_0 <= 178) || (LA224_0 >= 195 && LA224_0 <= 202)) )
            	{
            	    alt224 = 1;
            	}
            	switch (alt224) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:771:8: struct_member_declarations
            	        {
            	        	PushFollow(FOLLOW_struct_member_declarations_in_struct_body5596);
            	        	struct_member_declarations763 = struct_member_declarations();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_member_declarations763.Tree);

            	        }
            	        break;

            	}

            	char_literal764=(IToken)Match(input,63,FOLLOW_63_in_struct_body5601); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal764_tree = (object)adaptor.Create(char_literal764);
            		adaptor.AddChild(root_0, char_literal764_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 222, struct_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "struct_body"

    public class struct_member_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "struct_member_declarations"
    // G:\\downloads\\antlr\\cs.g:772:1: struct_member_declarations : ( struct_member_declaration )+ ;
    public csParser.struct_member_declarations_return struct_member_declarations() // throws RecognitionException [1]
    {   
        csParser.struct_member_declarations_return retval = new csParser.struct_member_declarations_return();
        retval.Start = input.LT(1);
        int struct_member_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.struct_member_declaration_return struct_member_declaration765 = default(csParser.struct_member_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 223) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:772:27: ( ( struct_member_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:773:2: ( struct_member_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:773:2: ( struct_member_declaration )+
            	int cnt225 = 0;
            	do 
            	{
            	    int alt225 = 2;
            	    int LA225_0 = input.LA(1);

            	    if ( (LA225_0 == IDENTIFIER || LA225_0 == ENUM || (LA225_0 >= 64 && LA225_0 <= 65) || (LA225_0 >= 67 && LA225_0 <= 82) || LA225_0 == 86 || LA225_0 == 97 || (LA225_0 >= 132 && LA225_0 <= 133) || (LA225_0 >= 135 && LA225_0 <= 152) || (LA225_0 >= 154 && LA225_0 <= 155) || (LA225_0 >= 157 && LA225_0 <= 170) || LA225_0 == 172 || (LA225_0 >= 174 && LA225_0 <= 175) || (LA225_0 >= 177 && LA225_0 <= 178) || (LA225_0 >= 195 && LA225_0 <= 202)) )
            	    {
            	        alt225 = 1;
            	    }


            	    switch (alt225) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:773:2: struct_member_declaration
            			    {
            			    	PushFollow(FOLLOW_struct_member_declaration_in_struct_member_declarations5608);
            			    	struct_member_declaration765 = struct_member_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_member_declaration765.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt225 >= 1 ) goto loop225;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(225, input);
            		            throw eee;
            	    }
            	    cnt225++;
            	} while (true);

            	loop225:
            		;	// Stops C# compiler whinging that label 'loop225' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 223, struct_member_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "struct_member_declarations"

    public class struct_member_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "struct_member_declaration"
    // G:\\downloads\\antlr\\cs.g:774:1: struct_member_declaration : ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration ) ;
    public csParser.struct_member_declaration_return struct_member_declaration() // throws RecognitionException [1]
    {   
        csParser.struct_member_declaration_return retval = new csParser.struct_member_declaration_return();
        retval.Start = input.LT(1);
        int struct_member_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal767 = null;
        IToken char_literal770 = null;
        IToken string_literal772 = null;
        IToken string_literal779 = null;
        IToken char_literal785 = null;
        csParser.modifiers_return m = default(csParser.modifiers_return);

        csParser.attributes_return attributes766 = default(csParser.attributes_return);

        csParser.type_return type768 = default(csParser.type_return);

        csParser.constant_declarators_return constant_declarators769 = default(csParser.constant_declarators_return);

        csParser.event_declaration_return event_declaration771 = default(csParser.event_declaration_return);

        csParser.method_declaration_return method_declaration773 = default(csParser.method_declaration_return);

        csParser.interface_declaration_return interface_declaration774 = default(csParser.interface_declaration_return);

        csParser.class_declaration_return class_declaration775 = default(csParser.class_declaration_return);

        csParser.struct_declaration_return struct_declaration776 = default(csParser.struct_declaration_return);

        csParser.interface_declaration_return interface_declaration777 = default(csParser.interface_declaration_return);

        csParser.class_declaration_return class_declaration778 = default(csParser.class_declaration_return);

        csParser.method_declaration_return method_declaration780 = default(csParser.method_declaration_return);

        csParser.type_return type781 = default(csParser.type_return);

        csParser.method_declaration_return method_declaration782 = default(csParser.method_declaration_return);

        csParser.property_declaration_return property_declaration783 = default(csParser.property_declaration_return);

        csParser.type_name_return type_name784 = default(csParser.type_name_return);

        csParser.indexer_declaration_return indexer_declaration786 = default(csParser.indexer_declaration_return);

        csParser.indexer_declaration_return indexer_declaration787 = default(csParser.indexer_declaration_return);

        csParser.field_declaration_return field_declaration788 = default(csParser.field_declaration_return);

        csParser.operator_declaration_return operator_declaration789 = default(csParser.operator_declaration_return);

        csParser.struct_declaration_return struct_declaration790 = default(csParser.struct_declaration_return);

        csParser.enum_declaration_return enum_declaration791 = default(csParser.enum_declaration_return);

        csParser.delegate_declaration_return delegate_declaration792 = default(csParser.delegate_declaration_return);

        csParser.conversion_operator_declaration_return conversion_operator_declaration793 = default(csParser.conversion_operator_declaration_return);

        csParser.constructor_declaration_return constructor_declaration794 = default(csParser.constructor_declaration_return);


        object string_literal767_tree=null;
        object char_literal770_tree=null;
        object string_literal772_tree=null;
        object string_literal779_tree=null;
        object char_literal785_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 224) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:774:26: ( ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration ) )
            // G:\\downloads\\antlr\\cs.g:775:2: ( attributes )? (m= modifiers )? ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:775:2: ( attributes )?
            	int alt226 = 2;
            	int LA226_0 = input.LA(1);

            	if ( (LA226_0 == 86) )
            	{
            	    alt226 = 1;
            	}
            	switch (alt226) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:775:2: attributes
            	        {
            	        	PushFollow(FOLLOW_attributes_in_struct_member_declaration5617);
            	        	attributes766 = attributes();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes766.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:775:17: (m= modifiers )?
            	int alt227 = 2;
            	int LA227_0 = input.LA(1);

            	if ( (LA227_0 == 64 || (LA227_0 >= 68 && LA227_0 <= 80)) )
            	{
            	    alt227 = 1;
            	}
            	switch (alt227) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:775:17: m= modifiers
            	        {
            	        	PushFollow(FOLLOW_modifiers_in_struct_member_declaration5624);
            	        	m = modifiers();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, m.Tree);

            	        }
            	        break;

            	}

            	// G:\\downloads\\antlr\\cs.g:776:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration )
            	int alt230 = 12;
            	alt230 = dfa230.Predict(input);
            	switch (alt230) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:776:4: 'const' type constant_declarators ';'
            	        {
            	        	string_literal767=(IToken)Match(input,81,FOLLOW_81_in_struct_member_declaration5630); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal767_tree = (object)adaptor.Create(string_literal767);
            	        		adaptor.AddChild(root_0, string_literal767_tree);
            	        	}
            	        	PushFollow(FOLLOW_type_in_struct_member_declaration5634);
            	        	type768 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type768.Tree);
            	        	PushFollow(FOLLOW_constant_declarators_in_struct_member_declaration5638);
            	        	constant_declarators769 = constant_declarators();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators769.Tree);
            	        	char_literal770=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_struct_member_declaration5642); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal770_tree = (object)adaptor.Create(char_literal770);
            	        		adaptor.AddChild(root_0, char_literal770_tree);
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:777:4: event_declaration
            	        {
            	        	PushFollow(FOLLOW_event_declaration_in_struct_member_declaration5647);
            	        	event_declaration771 = event_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, event_declaration771.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // G:\\downloads\\antlr\\cs.g:778:4: 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration )
            	        {
            	        	string_literal772=(IToken)Match(input,67,FOLLOW_67_in_struct_member_declaration5654); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal772_tree = (object)adaptor.Create(string_literal772);
            	        		adaptor.AddChild(root_0, string_literal772_tree);
            	        	}
            	        	// G:\\downloads\\antlr\\cs.g:778:14: ( method_declaration | interface_declaration | class_declaration | struct_declaration )
            	        	int alt228 = 4;
            	        	switch ( input.LA(1) ) 
            	        	{
            	        	case IDENTIFIER:
            	        	case Real_literal:
            	        	case NUMBER:
            	        	case Hex_number:
            	        	case Character_literal:
            	        	case STRINGLITERAL:
            	        	case Verbatim_string_literal:
            	        	case TRUE:
            	        	case FALSE:
            	        	case NULL:
            	        	case 65:
            	        	case 132:
            	        	case 133:
            	        	case 135:
            	        	case 136:
            	        	case 137:
            	        	case 138:
            	        	case 139:
            	        	case 140:
            	        	case 141:
            	        	case 142:
            	        	case 143:
            	        	case 144:
            	        	case 145:
            	        	case 146:
            	        	case 147:
            	        	case 148:
            	        	case 150:
            	        	case 151:
            	        	case 152:
            	        	case 154:
            	        	case 157:
            	        	case 158:
            	        	case 159:
            	        	case 160:
            	        	case 161:
            	        	case 162:
            	        	case 163:
            	        	case 164:
            	        	case 165:
            	        	case 166:
            	        	case 167:
            	        	case 168:
            	        	case 170:
            	        	case 177:
            	        	case 178:
            	        	case 195:
            	        	case 196:
            	        	case 197:
            	        	case 198:
            	        	case 199:
            	        	case 200:
            	        	case 201:
            	        	case 202:
            	        		{
            	        	    alt228 = 1;
            	        	    }
            	        	    break;
            	        	case 172:
            	        		{
            	        	    alt228 = 2;
            	        	    }
            	        	    break;
            	        	case 155:
            	        		{
            	        	    alt228 = 3;
            	        	    }
            	        	    break;
            	        	case 169:
            	        		{
            	        	    alt228 = 4;
            	        	    }
            	        	    break;
            	        		default:
            	        		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        		    NoViableAltException nvae_d228s0 =
            	        		        new NoViableAltException("", 228, 0, input);

            	        		    throw nvae_d228s0;
            	        	}

            	        	switch (alt228) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:778:15: method_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_method_declaration_in_struct_member_declaration5657);
            	        	        	method_declaration773 = method_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration773.Tree);

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:779:9: interface_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_interface_declaration_in_struct_member_declaration5668);
            	        	        	interface_declaration774 = interface_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration774.Tree);

            	        	        }
            	        	        break;
            	        	    case 3 :
            	        	        // G:\\downloads\\antlr\\cs.g:780:9: class_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_class_declaration_in_struct_member_declaration5679);
            	        	        	class_declaration775 = class_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration775.Tree);

            	        	        }
            	        	        break;
            	        	    case 4 :
            	        	        // G:\\downloads\\antlr\\cs.g:781:9: struct_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_struct_declaration_in_struct_member_declaration5690);
            	        	        	struct_declaration776 = struct_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration776.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 4 :
            	        // G:\\downloads\\antlr\\cs.g:783:4: interface_declaration
            	        {
            	        	PushFollow(FOLLOW_interface_declaration_in_struct_member_declaration5697);
            	        	interface_declaration777 = interface_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, interface_declaration777.Tree);

            	        }
            	        break;
            	    case 5 :
            	        // G:\\downloads\\antlr\\cs.g:784:4: class_declaration
            	        {
            	        	PushFollow(FOLLOW_class_declaration_in_struct_member_declaration5703);
            	        	class_declaration778 = class_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_declaration778.Tree);

            	        }
            	        break;
            	    case 6 :
            	        // G:\\downloads\\antlr\\cs.g:785:4: 'void' method_declaration
            	        {
            	        	string_literal779=(IToken)Match(input,82,FOLLOW_82_in_struct_member_declaration5710); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal779_tree = (object)adaptor.Create(string_literal779);
            	        		adaptor.AddChild(root_0, string_literal779_tree);
            	        	}
            	        	PushFollow(FOLLOW_method_declaration_in_struct_member_declaration5714);
            	        	method_declaration780 = method_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration780.Tree);

            	        }
            	        break;
            	    case 7 :
            	        // G:\\downloads\\antlr\\cs.g:786:4: type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
            	        {
            	        	PushFollow(FOLLOW_type_in_struct_member_declaration5719);
            	        	type781 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type781.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:786:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )
            	        	int alt229 = 6;
            	        	alt229 = dfa229.Predict(input);
            	        	switch (alt229) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:786:11: ( member_name '(' )=> method_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_method_declaration_in_struct_member_declaration5733);
            	        	        	method_declaration782 = method_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration782.Tree);

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:787:8: ( member_name '{' )=> property_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_property_declaration_in_struct_member_declaration5752);
            	        	        	property_declaration783 = property_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, property_declaration783.Tree);

            	        	        }
            	        	        break;
            	        	    case 3 :
            	        	        // G:\\downloads\\antlr\\cs.g:788:8: ( member_name '.' 'this' )=> type_name '.' indexer_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_type_name_in_struct_member_declaration5775);
            	        	        	type_name784 = type_name();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type_name784.Tree);
            	        	        	char_literal785=(IToken)Match(input,DOT,FOLLOW_DOT_in_struct_member_declaration5777); if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 )
            	        	        	{char_literal785_tree = (object)adaptor.Create(char_literal785);
            	        	        		adaptor.AddChild(root_0, char_literal785_tree);
            	        	        	}
            	        	        	PushFollow(FOLLOW_indexer_declaration_in_struct_member_declaration5779);
            	        	        	indexer_declaration786 = indexer_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration786.Tree);

            	        	        }
            	        	        break;
            	        	    case 4 :
            	        	        // G:\\downloads\\antlr\\cs.g:789:8: indexer_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_indexer_declaration_in_struct_member_declaration5788);
            	        	        	indexer_declaration787 = indexer_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declaration787.Tree);

            	        	        }
            	        	        break;
            	        	    case 5 :
            	        	        // G:\\downloads\\antlr\\cs.g:790:11: field_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_field_declaration_in_struct_member_declaration5801);
            	        	        	field_declaration788 = field_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, field_declaration788.Tree);

            	        	        }
            	        	        break;
            	        	    case 6 :
            	        	        // G:\\downloads\\antlr\\cs.g:791:11: operator_declaration
            	        	        {
            	        	        	PushFollow(FOLLOW_operator_declaration_in_struct_member_declaration5819);
            	        	        	operator_declaration789 = operator_declaration();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_declaration789.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 8 :
            	        // G:\\downloads\\antlr\\cs.g:795:4: struct_declaration
            	        {
            	        	PushFollow(FOLLOW_struct_declaration_in_struct_member_declaration5837);
            	        	struct_declaration790 = struct_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, struct_declaration790.Tree);

            	        }
            	        break;
            	    case 9 :
            	        // G:\\downloads\\antlr\\cs.g:796:4: enum_declaration
            	        {
            	        	PushFollow(FOLLOW_enum_declaration_in_struct_member_declaration5843);
            	        	enum_declaration791 = enum_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, enum_declaration791.Tree);

            	        }
            	        break;
            	    case 10 :
            	        // G:\\downloads\\antlr\\cs.g:797:4: delegate_declaration
            	        {
            	        	PushFollow(FOLLOW_delegate_declaration_in_struct_member_declaration5850);
            	        	delegate_declaration792 = delegate_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration792.Tree);

            	        }
            	        break;
            	    case 11 :
            	        // G:\\downloads\\antlr\\cs.g:798:4: conversion_operator_declaration
            	        {
            	        	PushFollow(FOLLOW_conversion_operator_declaration_in_struct_member_declaration5856);
            	        	conversion_operator_declaration793 = conversion_operator_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conversion_operator_declaration793.Tree);

            	        }
            	        break;
            	    case 12 :
            	        // G:\\downloads\\antlr\\cs.g:799:4: constructor_declaration
            	        {
            	        	PushFollow(FOLLOW_constructor_declaration_in_struct_member_declaration5861);
            	        	constructor_declaration794 = constructor_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_declaration794.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 224, struct_member_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "struct_member_declaration"

    public class indexer_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "indexer_declaration"
    // G:\\downloads\\antlr\\cs.g:805:1: indexer_declaration : indexer_declarator '{' accessor_declarations '}' ;
    public csParser.indexer_declaration_return indexer_declaration() // throws RecognitionException [1]
    {   
        csParser.indexer_declaration_return retval = new csParser.indexer_declaration_return();
        retval.Start = input.LT(1);
        int indexer_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal796 = null;
        IToken char_literal798 = null;
        csParser.indexer_declarator_return indexer_declarator795 = default(csParser.indexer_declarator_return);

        csParser.accessor_declarations_return accessor_declarations797 = default(csParser.accessor_declarations_return);


        object char_literal796_tree=null;
        object char_literal798_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 225) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:805:20: ( indexer_declarator '{' accessor_declarations '}' )
            // G:\\downloads\\antlr\\cs.g:806:2: indexer_declarator '{' accessor_declarations '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_indexer_declarator_in_indexer_declaration5878);
            	indexer_declarator795 = indexer_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, indexer_declarator795.Tree);
            	char_literal796=(IToken)Match(input,62,FOLLOW_62_in_indexer_declaration5882); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal796_tree = (object)adaptor.Create(char_literal796);
            		adaptor.AddChild(root_0, char_literal796_tree);
            	}
            	PushFollow(FOLLOW_accessor_declarations_in_indexer_declaration5886);
            	accessor_declarations797 = accessor_declarations();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, accessor_declarations797.Tree);
            	char_literal798=(IToken)Match(input,63,FOLLOW_63_in_indexer_declaration5890); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal798_tree = (object)adaptor.Create(char_literal798);
            		adaptor.AddChild(root_0, char_literal798_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 225, indexer_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "indexer_declaration"

    public class indexer_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "indexer_declarator"
    // G:\\downloads\\antlr\\cs.g:807:1: indexer_declarator : 'this' '[' formal_parameter_list ']' ;
    public csParser.indexer_declarator_return indexer_declarator() // throws RecognitionException [1]
    {   
        csParser.indexer_declarator_return retval = new csParser.indexer_declarator_return();
        retval.Start = input.LT(1);
        int indexer_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal799 = null;
        IToken char_literal800 = null;
        IToken char_literal802 = null;
        csParser.formal_parameter_list_return formal_parameter_list801 = default(csParser.formal_parameter_list_return);


        object string_literal799_tree=null;
        object char_literal800_tree=null;
        object char_literal802_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 226) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:807:19: ( 'this' '[' formal_parameter_list ']' )
            // G:\\downloads\\antlr\\cs.g:809:2: 'this' '[' formal_parameter_list ']'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal799=(IToken)Match(input,83,FOLLOW_83_in_indexer_declarator5900); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal799_tree = (object)adaptor.Create(string_literal799);
            		adaptor.AddChild(root_0, string_literal799_tree);
            	}
            	char_literal800=(IToken)Match(input,86,FOLLOW_86_in_indexer_declarator5904); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal800_tree = (object)adaptor.Create(char_literal800);
            		adaptor.AddChild(root_0, char_literal800_tree);
            	}
            	PushFollow(FOLLOW_formal_parameter_list_in_indexer_declarator5908);
            	formal_parameter_list801 = formal_parameter_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list801.Tree);
            	char_literal802=(IToken)Match(input,87,FOLLOW_87_in_indexer_declarator5912); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal802_tree = (object)adaptor.Create(char_literal802);
            		adaptor.AddChild(root_0, char_literal802_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 226, indexer_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "indexer_declarator"

    public class operator_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "operator_declaration"
    // G:\\downloads\\antlr\\cs.g:812:1: operator_declaration : operator_declarator operator_body ;
    public csParser.operator_declaration_return operator_declaration() // throws RecognitionException [1]
    {   
        csParser.operator_declaration_return retval = new csParser.operator_declaration_return();
        retval.Start = input.LT(1);
        int operator_declaration_StartIndex = input.Index();
        object root_0 = null;

        csParser.operator_declarator_return operator_declarator803 = default(csParser.operator_declarator_return);

        csParser.operator_body_return operator_body804 = default(csParser.operator_body_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 227) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:812:21: ( operator_declarator operator_body )
            // G:\\downloads\\antlr\\cs.g:813:2: operator_declarator operator_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_operator_declarator_in_operator_declaration5923);
            	operator_declarator803 = operator_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_declarator803.Tree);
            	PushFollow(FOLLOW_operator_body_in_operator_declaration5927);
            	operator_body804 = operator_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_body804.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 227, operator_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "operator_declaration"

    public class operator_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "operator_declarator"
    // G:\\downloads\\antlr\\cs.g:814:1: operator_declarator : 'operator' ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator unary_operator_declarator | overloadable_binary_operator binary_operator_declarator ) ;
    public csParser.operator_declarator_return operator_declarator() // throws RecognitionException [1]
    {   
        csParser.operator_declarator_return retval = new csParser.operator_declarator_return();
        retval.Start = input.LT(1);
        int operator_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal805 = null;
        IToken set806 = null;
        IToken char_literal807 = null;
        csParser.type_return type808 = default(csParser.type_return);

        csParser.identifier_return identifier809 = default(csParser.identifier_return);

        csParser.binary_operator_declarator_return binary_operator_declarator810 = default(csParser.binary_operator_declarator_return);

        csParser.unary_operator_declarator_return unary_operator_declarator811 = default(csParser.unary_operator_declarator_return);

        csParser.overloadable_unary_operator_return overloadable_unary_operator812 = default(csParser.overloadable_unary_operator_return);

        csParser.unary_operator_declarator_return unary_operator_declarator813 = default(csParser.unary_operator_declarator_return);

        csParser.overloadable_binary_operator_return overloadable_binary_operator814 = default(csParser.overloadable_binary_operator_return);

        csParser.binary_operator_declarator_return binary_operator_declarator815 = default(csParser.binary_operator_declarator_return);


        object string_literal805_tree=null;
        object set806_tree=null;
        object char_literal807_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 228) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:814:20: ( 'operator' ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator unary_operator_declarator | overloadable_binary_operator binary_operator_declarator ) )
            // G:\\downloads\\antlr\\cs.g:815:2: 'operator' ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator unary_operator_declarator | overloadable_binary_operator binary_operator_declarator )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal805=(IToken)Match(input,173,FOLLOW_173_in_operator_declarator5935); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal805_tree = (object)adaptor.Create(string_literal805);
            		adaptor.AddChild(root_0, string_literal805_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:816:3: ( ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator ) | overloadable_unary_operator unary_operator_declarator | overloadable_binary_operator binary_operator_declarator )
            	int alt232 = 3;
            	switch ( input.LA(1) ) 
            	{
            	case MINUS:
            	case 104:
            		{
            	    alt232 = 1;
            	    }
            	    break;
            	case TRUE:
            	case FALSE:
            	case 102:
            	case 103:
            	case 105:
            	case 106:
            		{
            	    alt232 = 2;
            	    }
            	    break;
            	case GT:
            	case 99:
            	case 100:
            	case 116:
            	case 117:
            	case 118:
            	case 119:
            	case 120:
            	case 121:
            	case 124:
            	case 125:
            	case 126:
            	case 127:
            		{
            	    alt232 = 3;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		    NoViableAltException nvae_d232s0 =
            		        new NoViableAltException("", 232, 0, input);

            		    throw nvae_d232s0;
            	}

            	switch (alt232) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:816:4: ( '+' | '-' ) '(' type identifier ( binary_operator_declarator | unary_operator_declarator )
            	        {
            	        	set806 = (IToken)input.LT(1);
            	        	if ( input.LA(1) == MINUS || input.LA(1) == 104 ) 
            	        	{
            	        	    input.Consume();
            	        	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set806));
            	        	    state.errorRecovery = false;state.failed = false;
            	        	}
            	        	else 
            	        	{
            	        	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	        	    throw mse;
            	        	}

            	        	char_literal807=(IToken)Match(input,88,FOLLOW_88_in_operator_declarator5953); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal807_tree = (object)adaptor.Create(char_literal807);
            	        		adaptor.AddChild(root_0, char_literal807_tree);
            	        	}
            	        	PushFollow(FOLLOW_type_in_operator_declarator5957);
            	        	type808 = type();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type808.Tree);
            	        	PushFollow(FOLLOW_identifier_in_operator_declarator5961);
            	        	identifier809 = identifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier809.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:816:42: ( binary_operator_declarator | unary_operator_declarator )
            	        	int alt231 = 2;
            	        	int LA231_0 = input.LA(1);

            	        	if ( (LA231_0 == 89) )
            	        	{
            	        	    alt231 = 1;
            	        	}
            	        	else if ( (LA231_0 == RPAREN) )
            	        	{
            	        	    alt231 = 2;
            	        	}
            	        	else 
            	        	{
            	        	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	        	    NoViableAltException nvae_d231s0 =
            	        	        new NoViableAltException("", 231, 0, input);

            	        	    throw nvae_d231s0;
            	        	}
            	        	switch (alt231) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:816:43: binary_operator_declarator
            	        	        {
            	        	        	PushFollow(FOLLOW_binary_operator_declarator_in_operator_declarator5964);
            	        	        	binary_operator_declarator810 = binary_operator_declarator();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, binary_operator_declarator810.Tree);

            	        	        }
            	        	        break;
            	        	    case 2 :
            	        	        // G:\\downloads\\antlr\\cs.g:816:72: unary_operator_declarator
            	        	        {
            	        	        	PushFollow(FOLLOW_unary_operator_declarator_in_operator_declarator5968);
            	        	        	unary_operator_declarator811 = unary_operator_declarator();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_operator_declarator811.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:817:5: overloadable_unary_operator unary_operator_declarator
            	        {
            	        	PushFollow(FOLLOW_overloadable_unary_operator_in_operator_declarator5975);
            	        	overloadable_unary_operator812 = overloadable_unary_operator();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, overloadable_unary_operator812.Tree);
            	        	PushFollow(FOLLOW_unary_operator_declarator_in_operator_declarator5979);
            	        	unary_operator_declarator813 = unary_operator_declarator();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_operator_declarator813.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // G:\\downloads\\antlr\\cs.g:818:5: overloadable_binary_operator binary_operator_declarator
            	        {
            	        	PushFollow(FOLLOW_overloadable_binary_operator_in_operator_declarator5985);
            	        	overloadable_binary_operator814 = overloadable_binary_operator();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, overloadable_binary_operator814.Tree);
            	        	PushFollow(FOLLOW_binary_operator_declarator_in_operator_declarator5989);
            	        	binary_operator_declarator815 = binary_operator_declarator();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, binary_operator_declarator815.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 228, operator_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "operator_declarator"

    public class unary_operator_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unary_operator_declarator"
    // G:\\downloads\\antlr\\cs.g:819:1: unary_operator_declarator : ')' ;
    public csParser.unary_operator_declarator_return unary_operator_declarator() // throws RecognitionException [1]
    {   
        csParser.unary_operator_declarator_return retval = new csParser.unary_operator_declarator_return();
        retval.Start = input.LT(1);
        int unary_operator_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal816 = null;

        object char_literal816_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 229) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:819:26: ( ')' )
            // G:\\downloads\\antlr\\cs.g:820:5: ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal816=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_unary_operator_declarator6001); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal816_tree = (object)adaptor.Create(char_literal816);
            		adaptor.AddChild(root_0, char_literal816_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 229, unary_operator_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unary_operator_declarator"

    public class overloadable_unary_operator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "overloadable_unary_operator"
    // G:\\downloads\\antlr\\cs.g:821:1: overloadable_unary_operator : ( '!' | '~' | '++' | '--' | 'true' | 'false' );
    public csParser.overloadable_unary_operator_return overloadable_unary_operator() // throws RecognitionException [1]
    {   
        csParser.overloadable_unary_operator_return retval = new csParser.overloadable_unary_operator_return();
        retval.Start = input.LT(1);
        int overloadable_unary_operator_StartIndex = input.Index();
        object root_0 = null;

        IToken set817 = null;

        object set817_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 230) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:821:28: ( '!' | '~' | '++' | '--' | 'true' | 'false' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set817 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= TRUE && input.LA(1) <= FALSE) || (input.LA(1) >= 102 && input.LA(1) <= 103) || (input.LA(1) >= 105 && input.LA(1) <= 106) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set817));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 230, overloadable_unary_operator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "overloadable_unary_operator"

    public class binary_operator_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "binary_operator_declarator"
    // G:\\downloads\\antlr\\cs.g:823:1: binary_operator_declarator : ',' type identifier ')' ;
    public csParser.binary_operator_declarator_return binary_operator_declarator() // throws RecognitionException [1]
    {   
        csParser.binary_operator_declarator_return retval = new csParser.binary_operator_declarator_return();
        retval.Start = input.LT(1);
        int binary_operator_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal818 = null;
        IToken char_literal821 = null;
        csParser.type_return type819 = default(csParser.type_return);

        csParser.identifier_return identifier820 = default(csParser.identifier_return);


        object char_literal818_tree=null;
        object char_literal821_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 231) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:823:27: ( ',' type identifier ')' )
            // G:\\downloads\\antlr\\cs.g:824:2: ',' type identifier ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal818=(IToken)Match(input,89,FOLLOW_89_in_binary_operator_declarator6044); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal818_tree = (object)adaptor.Create(char_literal818);
            		adaptor.AddChild(root_0, char_literal818_tree);
            	}
            	PushFollow(FOLLOW_type_in_binary_operator_declarator6048);
            	type819 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type819.Tree);
            	PushFollow(FOLLOW_identifier_in_binary_operator_declarator6052);
            	identifier820 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier820.Tree);
            	char_literal821=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_binary_operator_declarator6056); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal821_tree = (object)adaptor.Create(char_literal821);
            		adaptor.AddChild(root_0, char_literal821_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 231, binary_operator_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "binary_operator_declarator"

    public class overloadable_binary_operator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "overloadable_binary_operator"
    // G:\\downloads\\antlr\\cs.g:826:1: overloadable_binary_operator : ( '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>' '>' | '==' | '!=' | '>' | '<' | '>=' | '<=' );
    public csParser.overloadable_binary_operator_return overloadable_binary_operator() // throws RecognitionException [1]
    {   
        csParser.overloadable_binary_operator_return retval = new csParser.overloadable_binary_operator_return();
        retval.Start = input.LT(1);
        int overloadable_binary_operator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal822 = null;
        IToken char_literal823 = null;
        IToken char_literal824 = null;
        IToken char_literal825 = null;
        IToken char_literal826 = null;
        IToken char_literal827 = null;
        IToken string_literal828 = null;
        IToken char_literal829 = null;
        IToken char_literal830 = null;
        IToken string_literal831 = null;
        IToken string_literal832 = null;
        IToken char_literal833 = null;
        IToken char_literal834 = null;
        IToken string_literal835 = null;
        IToken string_literal836 = null;

        object char_literal822_tree=null;
        object char_literal823_tree=null;
        object char_literal824_tree=null;
        object char_literal825_tree=null;
        object char_literal826_tree=null;
        object char_literal827_tree=null;
        object string_literal828_tree=null;
        object char_literal829_tree=null;
        object char_literal830_tree=null;
        object string_literal831_tree=null;
        object string_literal832_tree=null;
        object char_literal833_tree=null;
        object char_literal834_tree=null;
        object string_literal835_tree=null;
        object string_literal836_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 232) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:826:29: ( '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>' '>' | '==' | '!=' | '>' | '<' | '>=' | '<=' )
            int alt233 = 14;
            alt233 = dfa233.Predict(input);
            switch (alt233) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:827:19: '*'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal822=(IToken)Match(input,100,FOLLOW_100_in_overloadable_binary_operator6067); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal822_tree = (object)adaptor.Create(char_literal822);
                    		adaptor.AddChild(root_0, char_literal822_tree);
                    	}

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:827:25: '/'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal823=(IToken)Match(input,118,FOLLOW_118_in_overloadable_binary_operator6071); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal823_tree = (object)adaptor.Create(char_literal823);
                    		adaptor.AddChild(root_0, char_literal823_tree);
                    	}

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:827:31: '%'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal824=(IToken)Match(input,119,FOLLOW_119_in_overloadable_binary_operator6075); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal824_tree = (object)adaptor.Create(char_literal824);
                    		adaptor.AddChild(root_0, char_literal824_tree);
                    	}

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:827:37: '&'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal825=(IToken)Match(input,117,FOLLOW_117_in_overloadable_binary_operator6079); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal825_tree = (object)adaptor.Create(char_literal825);
                    		adaptor.AddChild(root_0, char_literal825_tree);
                    	}

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:827:43: '|'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal826=(IToken)Match(input,127,FOLLOW_127_in_overloadable_binary_operator6083); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal826_tree = (object)adaptor.Create(char_literal826);
                    		adaptor.AddChild(root_0, char_literal826_tree);
                    	}

                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:827:49: '^'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal827=(IToken)Match(input,126,FOLLOW_126_in_overloadable_binary_operator6087); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal827_tree = (object)adaptor.Create(char_literal827);
                    		adaptor.AddChild(root_0, char_literal827_tree);
                    	}

                    }
                    break;
                case 7 :
                    // G:\\downloads\\antlr\\cs.g:827:55: '<<'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal828=(IToken)Match(input,120,FOLLOW_120_in_overloadable_binary_operator6091); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal828_tree = (object)adaptor.Create(string_literal828);
                    		adaptor.AddChild(root_0, string_literal828_tree);
                    	}

                    }
                    break;
                case 8 :
                    // G:\\downloads\\antlr\\cs.g:827:62: '>' '>'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal829=(IToken)Match(input,GT,FOLLOW_GT_in_overloadable_binary_operator6095); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal829_tree = (object)adaptor.Create(char_literal829);
                    		adaptor.AddChild(root_0, char_literal829_tree);
                    	}
                    	char_literal830=(IToken)Match(input,GT,FOLLOW_GT_in_overloadable_binary_operator6097); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal830_tree = (object)adaptor.Create(char_literal830);
                    		adaptor.AddChild(root_0, char_literal830_tree);
                    	}

                    }
                    break;
                case 9 :
                    // G:\\downloads\\antlr\\cs.g:827:72: '=='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal831=(IToken)Match(input,124,FOLLOW_124_in_overloadable_binary_operator6101); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal831_tree = (object)adaptor.Create(string_literal831);
                    		adaptor.AddChild(root_0, string_literal831_tree);
                    	}

                    }
                    break;
                case 10 :
                    // G:\\downloads\\antlr\\cs.g:827:79: '!='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal832=(IToken)Match(input,125,FOLLOW_125_in_overloadable_binary_operator6105); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal832_tree = (object)adaptor.Create(string_literal832);
                    		adaptor.AddChild(root_0, string_literal832_tree);
                    	}

                    }
                    break;
                case 11 :
                    // G:\\downloads\\antlr\\cs.g:827:86: '>'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal833=(IToken)Match(input,GT,FOLLOW_GT_in_overloadable_binary_operator6109); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal833_tree = (object)adaptor.Create(char_literal833);
                    		adaptor.AddChild(root_0, char_literal833_tree);
                    	}

                    }
                    break;
                case 12 :
                    // G:\\downloads\\antlr\\cs.g:827:92: '<'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	char_literal834=(IToken)Match(input,99,FOLLOW_99_in_overloadable_binary_operator6113); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{char_literal834_tree = (object)adaptor.Create(char_literal834);
                    		adaptor.AddChild(root_0, char_literal834_tree);
                    	}

                    }
                    break;
                case 13 :
                    // G:\\downloads\\antlr\\cs.g:827:98: '>='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal835=(IToken)Match(input,116,FOLLOW_116_in_overloadable_binary_operator6117); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal835_tree = (object)adaptor.Create(string_literal835);
                    		adaptor.AddChild(root_0, string_literal835_tree);
                    	}

                    }
                    break;
                case 14 :
                    // G:\\downloads\\antlr\\cs.g:827:105: '<='
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal836=(IToken)Match(input,121,FOLLOW_121_in_overloadable_binary_operator6121); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal836_tree = (object)adaptor.Create(string_literal836);
                    		adaptor.AddChild(root_0, string_literal836_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 232, overloadable_binary_operator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "overloadable_binary_operator"

    public class conversion_operator_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "conversion_operator_declaration"
    // G:\\downloads\\antlr\\cs.g:829:1: conversion_operator_declaration : conversion_operator_declarator operator_body ;
    public csParser.conversion_operator_declaration_return conversion_operator_declaration() // throws RecognitionException [1]
    {   
        csParser.conversion_operator_declaration_return retval = new csParser.conversion_operator_declaration_return();
        retval.Start = input.LT(1);
        int conversion_operator_declaration_StartIndex = input.Index();
        object root_0 = null;

        csParser.conversion_operator_declarator_return conversion_operator_declarator837 = default(csParser.conversion_operator_declarator_return);

        csParser.operator_body_return operator_body838 = default(csParser.operator_body_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 233) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:829:32: ( conversion_operator_declarator operator_body )
            // G:\\downloads\\antlr\\cs.g:830:2: conversion_operator_declarator operator_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_conversion_operator_declarator_in_conversion_operator_declaration6131);
            	conversion_operator_declarator837 = conversion_operator_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, conversion_operator_declarator837.Tree);
            	PushFollow(FOLLOW_operator_body_in_conversion_operator_declaration6135);
            	operator_body838 = operator_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, operator_body838.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 233, conversion_operator_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "conversion_operator_declaration"

    public class conversion_operator_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "conversion_operator_declarator"
    // G:\\downloads\\antlr\\cs.g:831:1: conversion_operator_declarator : ( 'implicit' | 'explicit' ) 'operator' type '(' type identifier ')' ;
    public csParser.conversion_operator_declarator_return conversion_operator_declarator() // throws RecognitionException [1]
    {   
        csParser.conversion_operator_declarator_return retval = new csParser.conversion_operator_declarator_return();
        retval.Start = input.LT(1);
        int conversion_operator_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken set839 = null;
        IToken string_literal840 = null;
        IToken char_literal842 = null;
        IToken char_literal845 = null;
        csParser.type_return type841 = default(csParser.type_return);

        csParser.type_return type843 = default(csParser.type_return);

        csParser.identifier_return identifier844 = default(csParser.identifier_return);


        object set839_tree=null;
        object string_literal840_tree=null;
        object char_literal842_tree=null;
        object char_literal845_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 234) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:831:31: ( ( 'implicit' | 'explicit' ) 'operator' type '(' type identifier ')' )
            // G:\\downloads\\antlr\\cs.g:832:2: ( 'implicit' | 'explicit' ) 'operator' type '(' type identifier ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set839 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 174 && input.LA(1) <= 175) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set839));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}

            	string_literal840=(IToken)Match(input,173,FOLLOW_173_in_conversion_operator_declarator6152); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal840_tree = (object)adaptor.Create(string_literal840);
            		adaptor.AddChild(root_0, string_literal840_tree);
            	}
            	PushFollow(FOLLOW_type_in_conversion_operator_declarator6156);
            	type841 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type841.Tree);
            	char_literal842=(IToken)Match(input,88,FOLLOW_88_in_conversion_operator_declarator6160); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal842_tree = (object)adaptor.Create(char_literal842);
            		adaptor.AddChild(root_0, char_literal842_tree);
            	}
            	PushFollow(FOLLOW_type_in_conversion_operator_declarator6164);
            	type843 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type843.Tree);
            	PushFollow(FOLLOW_identifier_in_conversion_operator_declarator6168);
            	identifier844 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier844.Tree);
            	char_literal845=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_conversion_operator_declarator6172); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal845_tree = (object)adaptor.Create(char_literal845);
            		adaptor.AddChild(root_0, char_literal845_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 234, conversion_operator_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "conversion_operator_declarator"

    public class operator_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "operator_body"
    // G:\\downloads\\antlr\\cs.g:833:1: operator_body : block ;
    public csParser.operator_body_return operator_body() // throws RecognitionException [1]
    {   
        csParser.operator_body_return retval = new csParser.operator_body_return();
        retval.Start = input.LT(1);
        int operator_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.block_return block846 = default(csParser.block_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 235) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:833:14: ( block )
            // G:\\downloads\\antlr\\cs.g:834:2: block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_block_in_operator_body6180);
            	block846 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block846.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 235, operator_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "operator_body"

    public class constructor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constructor_declaration"
    // G:\\downloads\\antlr\\cs.g:837:1: constructor_declaration : constructor_declarator constructor_body ;
    public csParser.constructor_declaration_return constructor_declaration() // throws RecognitionException [1]
    {   
        csParser.constructor_declaration_return retval = new csParser.constructor_declaration_return();
        retval.Start = input.LT(1);
        int constructor_declaration_StartIndex = input.Index();
        object root_0 = null;

        csParser.constructor_declarator_return constructor_declarator847 = default(csParser.constructor_declarator_return);

        csParser.constructor_body_return constructor_body848 = default(csParser.constructor_body_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 236) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:837:24: ( constructor_declarator constructor_body )
            // G:\\downloads\\antlr\\cs.g:838:2: constructor_declarator constructor_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_constructor_declarator_in_constructor_declaration6190);
            	constructor_declarator847 = constructor_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_declarator847.Tree);
            	PushFollow(FOLLOW_constructor_body_in_constructor_declaration6194);
            	constructor_body848 = constructor_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_body848.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 236, constructor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constructor_declaration"

    public class constructor_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constructor_declarator"
    // G:\\downloads\\antlr\\cs.g:839:1: constructor_declarator : identifier '(' ( formal_parameter_list )? ')' ( constructor_initializer )? ;
    public csParser.constructor_declarator_return constructor_declarator() // throws RecognitionException [1]
    {   
        csParser.constructor_declarator_return retval = new csParser.constructor_declarator_return();
        retval.Start = input.LT(1);
        int constructor_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal850 = null;
        IToken char_literal852 = null;
        csParser.identifier_return identifier849 = default(csParser.identifier_return);

        csParser.formal_parameter_list_return formal_parameter_list851 = default(csParser.formal_parameter_list_return);

        csParser.constructor_initializer_return constructor_initializer853 = default(csParser.constructor_initializer_return);


        object char_literal850_tree=null;
        object char_literal852_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 237) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:839:23: ( identifier '(' ( formal_parameter_list )? ')' ( constructor_initializer )? )
            // G:\\downloads\\antlr\\cs.g:840:2: identifier '(' ( formal_parameter_list )? ')' ( constructor_initializer )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_constructor_declarator6202);
            	identifier849 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier849.Tree);
            	char_literal850=(IToken)Match(input,88,FOLLOW_88_in_constructor_declarator6206); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal850_tree = (object)adaptor.Create(char_literal850);
            		adaptor.AddChild(root_0, char_literal850_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:840:21: ( formal_parameter_list )?
            	int alt234 = 2;
            	int LA234_0 = input.LA(1);

            	if ( (LA234_0 == IDENTIFIER || LA234_0 == 65 || (LA234_0 >= 82 && LA234_0 <= 83) || LA234_0 == 86 || (LA234_0 >= 91 && LA234_0 <= 92) || (LA234_0 >= 132 && LA234_0 <= 133) || (LA234_0 >= 135 && LA234_0 <= 148) || (LA234_0 >= 150 && LA234_0 <= 152) || LA234_0 == 154 || (LA234_0 >= 157 && LA234_0 <= 168) || (LA234_0 >= 170 && LA234_0 <= 171) || (LA234_0 >= 177 && LA234_0 <= 178) || (LA234_0 >= 195 && LA234_0 <= 202)) )
            	{
            	    alt234 = 1;
            	}
            	switch (alt234) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:840:21: formal_parameter_list
            	        {
            	        	PushFollow(FOLLOW_formal_parameter_list_in_constructor_declarator6210);
            	        	formal_parameter_list851 = formal_parameter_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, formal_parameter_list851.Tree);

            	        }
            	        break;

            	}

            	char_literal852=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_constructor_declarator6215); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal852_tree = (object)adaptor.Create(char_literal852);
            		adaptor.AddChild(root_0, char_literal852_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:840:52: ( constructor_initializer )?
            	int alt235 = 2;
            	int LA235_0 = input.LA(1);

            	if ( (LA235_0 == 90) )
            	{
            	    alt235 = 1;
            	}
            	switch (alt235) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:840:52: constructor_initializer
            	        {
            	        	PushFollow(FOLLOW_constructor_initializer_in_constructor_declarator6219);
            	        	constructor_initializer853 = constructor_initializer();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constructor_initializer853.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 237, constructor_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constructor_declarator"

    public class constructor_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constructor_initializer"
    // G:\\downloads\\antlr\\cs.g:841:1: constructor_initializer : ':' ( 'base' | 'this' ) '(' ( argument_list )? ')' ;
    public csParser.constructor_initializer_return constructor_initializer() // throws RecognitionException [1]
    {   
        csParser.constructor_initializer_return retval = new csParser.constructor_initializer_return();
        retval.Start = input.LT(1);
        int constructor_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal854 = null;
        IToken set855 = null;
        IToken char_literal856 = null;
        IToken char_literal858 = null;
        csParser.argument_list_return argument_list857 = default(csParser.argument_list_return);


        object char_literal854_tree=null;
        object set855_tree=null;
        object char_literal856_tree=null;
        object char_literal858_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 238) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:841:24: ( ':' ( 'base' | 'this' ) '(' ( argument_list )? ')' )
            // G:\\downloads\\antlr\\cs.g:842:2: ':' ( 'base' | 'this' ) '(' ( argument_list )? ')'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal854=(IToken)Match(input,90,FOLLOW_90_in_constructor_initializer6228); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal854_tree = (object)adaptor.Create(char_literal854);
            		adaptor.AddChild(root_0, char_literal854_tree);
            	}
            	set855 = (IToken)input.LT(1);
            	if ( input.LA(1) == 83 || input.LA(1) == 85 ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set855));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}

            	char_literal856=(IToken)Match(input,88,FOLLOW_88_in_constructor_initializer6242); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal856_tree = (object)adaptor.Create(char_literal856);
            		adaptor.AddChild(root_0, char_literal856_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:842:34: ( argument_list )?
            	int alt236 = 2;
            	int LA236_0 = input.LA(1);

            	if ( ((LA236_0 >= IDENTIFIER && LA236_0 <= NULL) || LA236_0 == MINUS || LA236_0 == 65 || LA236_0 == 68 || LA236_0 == 83 || LA236_0 == 85 || LA236_0 == 88 || (LA236_0 >= 91 && LA236_0 <= 98) || LA236_0 == 100 || (LA236_0 >= 102 && LA236_0 <= 106) || LA236_0 == 117 || (LA236_0 >= 132 && LA236_0 <= 133) || (LA236_0 >= 135 && LA236_0 <= 148) || (LA236_0 >= 150 && LA236_0 <= 152) || LA236_0 == 154 || (LA236_0 >= 157 && LA236_0 <= 168) || LA236_0 == 170 || (LA236_0 >= 177 && LA236_0 <= 178) || (LA236_0 >= 195 && LA236_0 <= 202)) )
            	{
            	    alt236 = 1;
            	}
            	switch (alt236) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:842:34: argument_list
            	        {
            	        	PushFollow(FOLLOW_argument_list_in_constructor_initializer6246);
            	        	argument_list857 = argument_list();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, argument_list857.Tree);

            	        }
            	        break;

            	}

            	char_literal858=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_constructor_initializer6251); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal858_tree = (object)adaptor.Create(char_literal858);
            		adaptor.AddChild(root_0, char_literal858_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 238, constructor_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constructor_initializer"

    public class constructor_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constructor_body"
    // G:\\downloads\\antlr\\cs.g:843:1: constructor_body : block ;
    public csParser.constructor_body_return constructor_body() // throws RecognitionException [1]
    {   
        csParser.constructor_body_return retval = new csParser.constructor_body_return();
        retval.Start = input.LT(1);
        int constructor_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.block_return block859 = default(csParser.block_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 239) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:843:17: ( block )
            // G:\\downloads\\antlr\\cs.g:844:2: block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_block_in_constructor_body6259);
            	block859 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block859.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 239, constructor_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constructor_body"

    public class destructor_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "destructor_declaration"
    // G:\\downloads\\antlr\\cs.g:853:1: destructor_declaration : '~' identifier '(' ')' destructor_body ;
    public csParser.destructor_declaration_return destructor_declaration() // throws RecognitionException [1]
    {   
        csParser.destructor_declaration_return retval = new csParser.destructor_declaration_return();
        retval.Start = input.LT(1);
        int destructor_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal860 = null;
        IToken char_literal862 = null;
        IToken char_literal863 = null;
        csParser.identifier_return identifier861 = default(csParser.identifier_return);

        csParser.destructor_body_return destructor_body864 = default(csParser.destructor_body_return);


        object char_literal860_tree=null;
        object char_literal862_tree=null;
        object char_literal863_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 240) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:853:23: ( '~' identifier '(' ')' destructor_body )
            // G:\\downloads\\antlr\\cs.g:854:2: '~' identifier '(' ')' destructor_body
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal860=(IToken)Match(input,106,FOLLOW_106_in_destructor_declaration6275); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal860_tree = (object)adaptor.Create(char_literal860);
            		adaptor.AddChild(root_0, char_literal860_tree);
            	}
            	PushFollow(FOLLOW_identifier_in_destructor_declaration6278);
            	identifier861 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier861.Tree);
            	char_literal862=(IToken)Match(input,88,FOLLOW_88_in_destructor_declaration6282); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal862_tree = (object)adaptor.Create(char_literal862);
            		adaptor.AddChild(root_0, char_literal862_tree);
            	}
            	char_literal863=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_destructor_declaration6286); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal863_tree = (object)adaptor.Create(char_literal863);
            		adaptor.AddChild(root_0, char_literal863_tree);
            	}
            	PushFollow(FOLLOW_destructor_body_in_destructor_declaration6291);
            	destructor_body864 = destructor_body();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, destructor_body864.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 240, destructor_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "destructor_declaration"

    public class destructor_body_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "destructor_body"
    // G:\\downloads\\antlr\\cs.g:855:1: destructor_body : block ;
    public csParser.destructor_body_return destructor_body() // throws RecognitionException [1]
    {   
        csParser.destructor_body_return retval = new csParser.destructor_body_return();
        retval.Start = input.LT(1);
        int destructor_body_StartIndex = input.Index();
        object root_0 = null;

        csParser.block_return block865 = default(csParser.block_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 241) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:855:16: ( block )
            // G:\\downloads\\antlr\\cs.g:856:2: block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_block_in_destructor_body6299);
            	block865 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block865.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 241, destructor_body_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "destructor_body"

    public class invocation_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "invocation_expression"
    // G:\\downloads\\antlr\\cs.g:859:1: invocation_expression : invocation_start ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments ;
    public csParser.invocation_expression_return invocation_expression() // throws RecognitionException [1]
    {   
        csParser.invocation_expression_return retval = new csParser.invocation_expression_return();
        retval.Start = input.LT(1);
        int invocation_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.invocation_start_return invocation_start866 = default(csParser.invocation_start_return);

        csParser.arguments_return arguments867 = default(csParser.arguments_return);

        csParser.invocation_part_return invocation_part868 = default(csParser.invocation_part_return);

        csParser.invocation_part_return invocation_part869 = default(csParser.invocation_part_return);

        csParser.arguments_return arguments870 = default(csParser.arguments_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 242) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:859:22: ( invocation_start ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )
            // G:\\downloads\\antlr\\cs.g:860:2: invocation_start ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_invocation_start_in_invocation_expression6309);
            	invocation_start866 = invocation_start();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_start866.Tree);
            	// G:\\downloads\\antlr\\cs.g:860:21: ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )*
            	do 
            	{
            	    int alt237 = 3;
            	    int LA237_0 = input.LA(1);

            	    if ( (LA237_0 == 88) )
            	    {
            	        int LA237_1 = input.LA(2);

            	        if ( (synpred31_cs()) )
            	        {
            	            alt237 = 1;
            	        }


            	    }
            	    else if ( ((LA237_0 >= DOT && LA237_0 <= PTR) || LA237_0 == 86) )
            	    {
            	        alt237 = 2;
            	    }


            	    switch (alt237) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:860:22: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:860:22: ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part )
            			    	// G:\\downloads\\antlr\\cs.g:860:23: ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part
            			    	{
            			    		PushFollow(FOLLOW_arguments_in_invocation_expression6331);
            			    		arguments867 = arguments();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments867.Tree);
            			    		PushFollow(FOLLOW_invocation_part_in_invocation_expression6335);
            			    		invocation_part868 = invocation_part();
            			    		state.followingStackPointer--;
            			    		if (state.failed) return retval;
            			    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part868.Tree);

            			    	}


            			    }
            			    break;
            			case 2 :
            			    // G:\\downloads\\antlr\\cs.g:861:9: invocation_part
            			    {
            			    	PushFollow(FOLLOW_invocation_part_in_invocation_expression6346);
            			    	invocation_part869 = invocation_part();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_part869.Tree);

            			    }
            			    break;

            			default:
            			    goto loop237;
            	    }
            	} while (true);

            	loop237:
            		;	// Stops C# compiler whining that label 'loop237' has no statements

            	PushFollow(FOLLOW_arguments_in_invocation_expression6352);
            	arguments870 = arguments();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, arguments870.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 242, invocation_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "invocation_expression"

    public class invocation_start_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "invocation_start"
    // G:\\downloads\\antlr\\cs.g:862:1: invocation_start : ( predefined_type | ( identifier '<' )=> identifier generic_argument_list | 'this' | 'base' | identifier ( '::' identifier )? | typeof_expression );
    public csParser.invocation_start_return invocation_start() // throws RecognitionException [1]
    {   
        csParser.invocation_start_return retval = new csParser.invocation_start_return();
        retval.Start = input.LT(1);
        int invocation_start_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal874 = null;
        IToken string_literal875 = null;
        IToken string_literal877 = null;
        csParser.predefined_type_return predefined_type871 = default(csParser.predefined_type_return);

        csParser.identifier_return identifier872 = default(csParser.identifier_return);

        csParser.generic_argument_list_return generic_argument_list873 = default(csParser.generic_argument_list_return);

        csParser.identifier_return identifier876 = default(csParser.identifier_return);

        csParser.identifier_return identifier878 = default(csParser.identifier_return);

        csParser.typeof_expression_return typeof_expression879 = default(csParser.typeof_expression_return);


        object string_literal874_tree=null;
        object string_literal875_tree=null;
        object string_literal877_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 243) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:862:17: ( predefined_type | ( identifier '<' )=> identifier generic_argument_list | 'this' | 'base' | identifier ( '::' identifier )? | typeof_expression )
            int alt239 = 6;
            switch ( input.LA(1) ) 
            {
            case 160:
            case 161:
            case 162:
            case 163:
            case 164:
            case 165:
            case 166:
            case 167:
            case 168:
            case 196:
            case 197:
            case 198:
            case 199:
            case 200:
            case 201:
            	{
                alt239 = 1;
                }
                break;
            case IDENTIFIER:
            case 65:
            case 132:
            case 133:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 170:
            case 177:
            case 178:
            case 195:
            case 202:
            	{
                int LA239_2 = input.LA(2);

                if ( ((LA239_2 >= DOT && LA239_2 <= PTR) || LA239_2 == 84 || LA239_2 == 86 || LA239_2 == 88) )
                {
                    alt239 = 5;
                }
                else if ( (LA239_2 == 99) && (synpred32_cs()) )
                {
                    alt239 = 2;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d239s2 =
                        new NoViableAltException("", 239, 2, input);

                    throw nvae_d239s2;
                }
                }
                break;
            case 83:
            	{
                alt239 = 3;
                }
                break;
            case 85:
            	{
                alt239 = 4;
                }
                break;
            case 98:
            	{
                alt239 = 6;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d239s0 =
            	        new NoViableAltException("", 239, 0, input);

            	    throw nvae_d239s0;
            }

            switch (alt239) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:863:2: predefined_type
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_predefined_type_in_invocation_start6360);
                    	predefined_type871 = predefined_type();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, predefined_type871.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:864:4: ( identifier '<' )=> identifier generic_argument_list
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_invocation_start6377);
                    	identifier872 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier872.Tree);
                    	PushFollow(FOLLOW_generic_argument_list_in_invocation_start6381);
                    	generic_argument_list873 = generic_argument_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, generic_argument_list873.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:865:4: 'this'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal874=(IToken)Match(input,83,FOLLOW_83_in_invocation_start6386); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal874_tree = (object)adaptor.Create(string_literal874);
                    		adaptor.AddChild(root_0, string_literal874_tree);
                    	}

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:866:4: 'base'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal875=(IToken)Match(input,85,FOLLOW_85_in_invocation_start6392); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal875_tree = (object)adaptor.Create(string_literal875);
                    		adaptor.AddChild(root_0, string_literal875_tree);
                    	}

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:867:4: identifier ( '::' identifier )?
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_identifier_in_invocation_start6397);
                    	identifier876 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier876.Tree);
                    	// G:\\downloads\\antlr\\cs.g:867:17: ( '::' identifier )?
                    	int alt238 = 2;
                    	int LA238_0 = input.LA(1);

                    	if ( (LA238_0 == 84) )
                    	{
                    	    alt238 = 1;
                    	}
                    	switch (alt238) 
                    	{
                    	    case 1 :
                    	        // G:\\downloads\\antlr\\cs.g:867:18: '::' identifier
                    	        {
                    	        	string_literal877=(IToken)Match(input,84,FOLLOW_84_in_invocation_start6402); if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 )
                    	        	{string_literal877_tree = (object)adaptor.Create(string_literal877);
                    	        		adaptor.AddChild(root_0, string_literal877_tree);
                    	        	}
                    	        	PushFollow(FOLLOW_identifier_in_invocation_start6406);
                    	        	identifier878 = identifier();
                    	        	state.followingStackPointer--;
                    	        	if (state.failed) return retval;
                    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier878.Tree);

                    	        }
                    	        break;

                    	}


                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:868:4: typeof_expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_typeof_expression_in_invocation_start6413);
                    	typeof_expression879 = typeof_expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, typeof_expression879.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 243, invocation_start_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "invocation_start"

    public class invocation_part_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "invocation_part"
    // G:\\downloads\\antlr\\cs.g:870:1: invocation_part : ( access_identifier | brackets );
    public csParser.invocation_part_return invocation_part() // throws RecognitionException [1]
    {   
        csParser.invocation_part_return retval = new csParser.invocation_part_return();
        retval.Start = input.LT(1);
        int invocation_part_StartIndex = input.Index();
        object root_0 = null;

        csParser.access_identifier_return access_identifier880 = default(csParser.access_identifier_return);

        csParser.brackets_return brackets881 = default(csParser.brackets_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 244) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:870:16: ( access_identifier | brackets )
            int alt240 = 2;
            int LA240_0 = input.LA(1);

            if ( ((LA240_0 >= DOT && LA240_0 <= PTR)) )
            {
                alt240 = 1;
            }
            else if ( (LA240_0 == 86) )
            {
                alt240 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d240s0 =
                    new NoViableAltException("", 240, 0, input);

                throw nvae_d240s0;
            }
            switch (alt240) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:871:3: access_identifier
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_access_identifier_in_invocation_part6436);
                    	access_identifier880 = access_identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, access_identifier880.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:872:4: brackets
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_brackets_in_invocation_part6441);
                    	brackets881 = brackets();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, brackets881.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 244, invocation_part_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "invocation_part"

    public class statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "statement"
    // G:\\downloads\\antlr\\cs.g:876:1: statement : ( ( declaration_statement )=> declaration_statement | ( identifier ':' )=> labeled_statement | embedded_statement );
    public csParser.statement_return statement() // throws RecognitionException [1]
    {   
        csParser.statement_return retval = new csParser.statement_return();
        retval.Start = input.LT(1);
        int statement_StartIndex = input.Index();
        object root_0 = null;

        csParser.declaration_statement_return declaration_statement882 = default(csParser.declaration_statement_return);

        csParser.labeled_statement_return labeled_statement883 = default(csParser.labeled_statement_return);

        csParser.embedded_statement_return embedded_statement884 = default(csParser.embedded_statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 245) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:876:10: ( ( declaration_statement )=> declaration_statement | ( identifier ':' )=> labeled_statement | embedded_statement )
            int alt241 = 3;
            alt241 = dfa241.Predict(input);
            switch (alt241) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:877:2: ( declaration_statement )=> declaration_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_declaration_statement_in_statement6458);
                    	declaration_statement882 = declaration_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, declaration_statement882.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:878:4: ( identifier ':' )=> labeled_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_labeled_statement_in_statement6473);
                    	labeled_statement883 = labeled_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, labeled_statement883.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:879:4: embedded_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_embedded_statement_in_statement6478);
                    	embedded_statement884 = embedded_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement884.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 245, statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "statement"

    public class embedded_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "embedded_statement"
    // G:\\downloads\\antlr\\cs.g:881:1: embedded_statement : ( block | selection_statement | iteration_statement | jump_statement | try_statement | checked_statement | unchecked_statement | lock_statement | using_statement | yield_statement | unsafe_statement | fixed_statement | expression_statement );
    public csParser.embedded_statement_return embedded_statement() // throws RecognitionException [1]
    {   
        csParser.embedded_statement_return retval = new csParser.embedded_statement_return();
        retval.Start = input.LT(1);
        int embedded_statement_StartIndex = input.Index();
        object root_0 = null;

        csParser.block_return block885 = default(csParser.block_return);

        csParser.selection_statement_return selection_statement886 = default(csParser.selection_statement_return);

        csParser.iteration_statement_return iteration_statement887 = default(csParser.iteration_statement_return);

        csParser.jump_statement_return jump_statement888 = default(csParser.jump_statement_return);

        csParser.try_statement_return try_statement889 = default(csParser.try_statement_return);

        csParser.checked_statement_return checked_statement890 = default(csParser.checked_statement_return);

        csParser.unchecked_statement_return unchecked_statement891 = default(csParser.unchecked_statement_return);

        csParser.lock_statement_return lock_statement892 = default(csParser.lock_statement_return);

        csParser.using_statement_return using_statement893 = default(csParser.using_statement_return);

        csParser.yield_statement_return yield_statement894 = default(csParser.yield_statement_return);

        csParser.unsafe_statement_return unsafe_statement895 = default(csParser.unsafe_statement_return);

        csParser.fixed_statement_return fixed_statement896 = default(csParser.fixed_statement_return);

        csParser.expression_statement_return expression_statement897 = default(csParser.expression_statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 246) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:881:19: ( block | selection_statement | iteration_statement | jump_statement | try_statement | checked_statement | unchecked_statement | lock_statement | using_statement | yield_statement | unsafe_statement | fixed_statement | expression_statement )
            int alt242 = 13;
            alt242 = dfa242.Predict(input);
            switch (alt242) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:882:2: block
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_block_in_embedded_statement6488);
                    	block885 = block();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block885.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:883:4: selection_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_selection_statement_in_embedded_statement6493);
                    	selection_statement886 = selection_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, selection_statement886.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:884:4: iteration_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_iteration_statement_in_embedded_statement6499);
                    	iteration_statement887 = iteration_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, iteration_statement887.Tree);

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:885:4: jump_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_jump_statement_in_embedded_statement6505);
                    	jump_statement888 = jump_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, jump_statement888.Tree);

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:886:4: try_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_try_statement_in_embedded_statement6512);
                    	try_statement889 = try_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, try_statement889.Tree);

                    }
                    break;
                case 6 :
                    // G:\\downloads\\antlr\\cs.g:887:4: checked_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_checked_statement_in_embedded_statement6517);
                    	checked_statement890 = checked_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, checked_statement890.Tree);

                    }
                    break;
                case 7 :
                    // G:\\downloads\\antlr\\cs.g:888:4: unchecked_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_unchecked_statement_in_embedded_statement6522);
                    	unchecked_statement891 = unchecked_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unchecked_statement891.Tree);

                    }
                    break;
                case 8 :
                    // G:\\downloads\\antlr\\cs.g:889:4: lock_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_lock_statement_in_embedded_statement6527);
                    	lock_statement892 = lock_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, lock_statement892.Tree);

                    }
                    break;
                case 9 :
                    // G:\\downloads\\antlr\\cs.g:890:4: using_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_using_statement_in_embedded_statement6532);
                    	using_statement893 = using_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, using_statement893.Tree);

                    }
                    break;
                case 10 :
                    // G:\\downloads\\antlr\\cs.g:891:4: yield_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_yield_statement_in_embedded_statement6538);
                    	yield_statement894 = yield_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, yield_statement894.Tree);

                    }
                    break;
                case 11 :
                    // G:\\downloads\\antlr\\cs.g:892:4: unsafe_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_unsafe_statement_in_embedded_statement6544);
                    	unsafe_statement895 = unsafe_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unsafe_statement895.Tree);

                    }
                    break;
                case 12 :
                    // G:\\downloads\\antlr\\cs.g:893:4: fixed_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_fixed_statement_in_embedded_statement6549);
                    	fixed_statement896 = fixed_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_statement896.Tree);

                    }
                    break;
                case 13 :
                    // G:\\downloads\\antlr\\cs.g:894:4: expression_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_statement_in_embedded_statement6554);
                    	expression_statement897 = expression_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression_statement897.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 246, embedded_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "embedded_statement"

    public class fixed_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "fixed_statement"
    // G:\\downloads\\antlr\\cs.g:896:1: fixed_statement : 'fixed' '(' pointer_type fixed_pointer_declarators ')' embedded_statement ;
    public csParser.fixed_statement_return fixed_statement() // throws RecognitionException [1]
    {   
        csParser.fixed_statement_return retval = new csParser.fixed_statement_return();
        retval.Start = input.LT(1);
        int fixed_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal898 = null;
        IToken char_literal899 = null;
        IToken char_literal902 = null;
        csParser.pointer_type_return pointer_type900 = default(csParser.pointer_type_return);

        csParser.fixed_pointer_declarators_return fixed_pointer_declarators901 = default(csParser.fixed_pointer_declarators_return);

        csParser.embedded_statement_return embedded_statement903 = default(csParser.embedded_statement_return);


        object string_literal898_tree=null;
        object char_literal899_tree=null;
        object char_literal902_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 247) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:896:16: ( 'fixed' '(' pointer_type fixed_pointer_declarators ')' embedded_statement )
            // G:\\downloads\\antlr\\cs.g:897:2: 'fixed' '(' pointer_type fixed_pointer_declarators ')' embedded_statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal898=(IToken)Match(input,176,FOLLOW_176_in_fixed_statement6564); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal898_tree = (object)adaptor.Create(string_literal898);
            		adaptor.AddChild(root_0, string_literal898_tree);
            	}
            	char_literal899=(IToken)Match(input,88,FOLLOW_88_in_fixed_statement6568); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal899_tree = (object)adaptor.Create(char_literal899);
            		adaptor.AddChild(root_0, char_literal899_tree);
            	}
            	PushFollow(FOLLOW_pointer_type_in_fixed_statement6572);
            	pointer_type900 = pointer_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, pointer_type900.Tree);
            	PushFollow(FOLLOW_fixed_pointer_declarators_in_fixed_statement6574);
            	fixed_pointer_declarators901 = fixed_pointer_declarators();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_declarators901.Tree);
            	char_literal902=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_fixed_statement6578); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal902_tree = (object)adaptor.Create(char_literal902);
            		adaptor.AddChild(root_0, char_literal902_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_fixed_statement6582);
            	embedded_statement903 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement903.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 247, fixed_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "fixed_statement"

    public class fixed_pointer_declarators_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "fixed_pointer_declarators"
    // G:\\downloads\\antlr\\cs.g:898:1: fixed_pointer_declarators : fixed_pointer_declarator ( ',' fixed_pointer_declarator )* ;
    public csParser.fixed_pointer_declarators_return fixed_pointer_declarators() // throws RecognitionException [1]
    {   
        csParser.fixed_pointer_declarators_return retval = new csParser.fixed_pointer_declarators_return();
        retval.Start = input.LT(1);
        int fixed_pointer_declarators_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal905 = null;
        csParser.fixed_pointer_declarator_return fixed_pointer_declarator904 = default(csParser.fixed_pointer_declarator_return);

        csParser.fixed_pointer_declarator_return fixed_pointer_declarator906 = default(csParser.fixed_pointer_declarator_return);


        object char_literal905_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 248) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:898:26: ( fixed_pointer_declarator ( ',' fixed_pointer_declarator )* )
            // G:\\downloads\\antlr\\cs.g:899:2: fixed_pointer_declarator ( ',' fixed_pointer_declarator )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_fixed_pointer_declarator_in_fixed_pointer_declarators6590);
            	fixed_pointer_declarator904 = fixed_pointer_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_declarator904.Tree);
            	// G:\\downloads\\antlr\\cs.g:899:29: ( ',' fixed_pointer_declarator )*
            	do 
            	{
            	    int alt243 = 2;
            	    int LA243_0 = input.LA(1);

            	    if ( (LA243_0 == 89) )
            	    {
            	        alt243 = 1;
            	    }


            	    switch (alt243) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:899:30: ',' fixed_pointer_declarator
            			    {
            			    	char_literal905=(IToken)Match(input,89,FOLLOW_89_in_fixed_pointer_declarators6595); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal905_tree = (object)adaptor.Create(char_literal905);
            			    		adaptor.AddChild(root_0, char_literal905_tree);
            			    	}
            			    	PushFollow(FOLLOW_fixed_pointer_declarator_in_fixed_pointer_declarators6599);
            			    	fixed_pointer_declarator906 = fixed_pointer_declarator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_declarator906.Tree);

            			    }
            			    break;

            			default:
            			    goto loop243;
            	    }
            	} while (true);

            	loop243:
            		;	// Stops C# compiler whining that label 'loop243' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 248, fixed_pointer_declarators_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "fixed_pointer_declarators"

    public class fixed_pointer_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "fixed_pointer_declarator"
    // G:\\downloads\\antlr\\cs.g:900:1: fixed_pointer_declarator : identifier '=' fixed_pointer_initializer ;
    public csParser.fixed_pointer_declarator_return fixed_pointer_declarator() // throws RecognitionException [1]
    {   
        csParser.fixed_pointer_declarator_return retval = new csParser.fixed_pointer_declarator_return();
        retval.Start = input.LT(1);
        int fixed_pointer_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal908 = null;
        csParser.identifier_return identifier907 = default(csParser.identifier_return);

        csParser.fixed_pointer_initializer_return fixed_pointer_initializer909 = default(csParser.fixed_pointer_initializer_return);


        object char_literal908_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 249) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:900:25: ( identifier '=' fixed_pointer_initializer )
            // G:\\downloads\\antlr\\cs.g:901:2: identifier '=' fixed_pointer_initializer
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_fixed_pointer_declarator6609);
            	identifier907 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier907.Tree);
            	char_literal908=(IToken)Match(input,66,FOLLOW_66_in_fixed_pointer_declarator6613); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal908_tree = (object)adaptor.Create(char_literal908);
            		adaptor.AddChild(root_0, char_literal908_tree);
            	}
            	PushFollow(FOLLOW_fixed_pointer_initializer_in_fixed_pointer_declarator6617);
            	fixed_pointer_initializer909 = fixed_pointer_initializer();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, fixed_pointer_initializer909.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 249, fixed_pointer_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "fixed_pointer_declarator"

    public class fixed_pointer_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "fixed_pointer_initializer"
    // G:\\downloads\\antlr\\cs.g:902:1: fixed_pointer_initializer : expression ;
    public csParser.fixed_pointer_initializer_return fixed_pointer_initializer() // throws RecognitionException [1]
    {   
        csParser.fixed_pointer_initializer_return retval = new csParser.fixed_pointer_initializer_return();
        retval.Start = input.LT(1);
        int fixed_pointer_initializer_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression910 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 250) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:902:26: ( expression )
            // G:\\downloads\\antlr\\cs.g:904:2: expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_fixed_pointer_initializer6627);
            	expression910 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression910.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 250, fixed_pointer_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "fixed_pointer_initializer"

    public class unsafe_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unsafe_statement"
    // G:\\downloads\\antlr\\cs.g:905:1: unsafe_statement : 'unsafe' block ;
    public csParser.unsafe_statement_return unsafe_statement() // throws RecognitionException [1]
    {   
        csParser.unsafe_statement_return retval = new csParser.unsafe_statement_return();
        retval.Start = input.LT(1);
        int unsafe_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal911 = null;
        csParser.block_return block912 = default(csParser.block_return);


        object string_literal911_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 251) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:905:17: ( 'unsafe' block )
            // G:\\downloads\\antlr\\cs.g:906:2: 'unsafe' block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal911=(IToken)Match(input,73,FOLLOW_73_in_unsafe_statement6634); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal911_tree = (object)adaptor.Create(string_literal911);
            		adaptor.AddChild(root_0, string_literal911_tree);
            	}
            	PushFollow(FOLLOW_block_in_unsafe_statement6638);
            	block912 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block912.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 251, unsafe_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unsafe_statement"

    public class labeled_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "labeled_statement"
    // G:\\downloads\\antlr\\cs.g:907:1: labeled_statement : identifier ':' statement ;
    public csParser.labeled_statement_return labeled_statement() // throws RecognitionException [1]
    {   
        csParser.labeled_statement_return retval = new csParser.labeled_statement_return();
        retval.Start = input.LT(1);
        int labeled_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal914 = null;
        csParser.identifier_return identifier913 = default(csParser.identifier_return);

        csParser.statement_return statement915 = default(csParser.statement_return);


        object char_literal914_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 252) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:907:18: ( identifier ':' statement )
            // G:\\downloads\\antlr\\cs.g:908:2: identifier ':' statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_labeled_statement6645);
            	identifier913 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier913.Tree);
            	char_literal914=(IToken)Match(input,90,FOLLOW_90_in_labeled_statement6649); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal914_tree = (object)adaptor.Create(char_literal914);
            		adaptor.AddChild(root_0, char_literal914_tree);
            	}
            	PushFollow(FOLLOW_statement_in_labeled_statement6653);
            	statement915 = statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement915.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 252, labeled_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "labeled_statement"

    public class declaration_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "declaration_statement"
    // G:\\downloads\\antlr\\cs.g:909:1: declaration_statement : ( local_variable_declaration | local_constant_declaration ) ';' ;
    public csParser.declaration_statement_return declaration_statement() // throws RecognitionException [1]
    {   
        csParser.declaration_statement_return retval = new csParser.declaration_statement_return();
        retval.Start = input.LT(1);
        int declaration_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal918 = null;
        csParser.local_variable_declaration_return local_variable_declaration916 = default(csParser.local_variable_declaration_return);

        csParser.local_constant_declaration_return local_constant_declaration917 = default(csParser.local_constant_declaration_return);


        object char_literal918_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 253) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:909:22: ( ( local_variable_declaration | local_constant_declaration ) ';' )
            // G:\\downloads\\antlr\\cs.g:910:2: ( local_variable_declaration | local_constant_declaration ) ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:910:2: ( local_variable_declaration | local_constant_declaration )
            	int alt244 = 2;
            	int LA244_0 = input.LA(1);

            	if ( (LA244_0 == IDENTIFIER || LA244_0 == 65 || LA244_0 == 82 || (LA244_0 >= 132 && LA244_0 <= 133) || (LA244_0 >= 135 && LA244_0 <= 148) || (LA244_0 >= 150 && LA244_0 <= 152) || LA244_0 == 154 || (LA244_0 >= 157 && LA244_0 <= 168) || LA244_0 == 170 || (LA244_0 >= 177 && LA244_0 <= 178) || (LA244_0 >= 195 && LA244_0 <= 202)) )
            	{
            	    alt244 = 1;
            	}
            	else if ( (LA244_0 == 81) )
            	{
            	    alt244 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d244s0 =
            	        new NoViableAltException("", 244, 0, input);

            	    throw nvae_d244s0;
            	}
            	switch (alt244) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:910:3: local_variable_declaration
            	        {
            	        	PushFollow(FOLLOW_local_variable_declaration_in_declaration_statement6662);
            	        	local_variable_declaration916 = local_variable_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration916.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:911:4: local_constant_declaration
            	        {
            	        	PushFollow(FOLLOW_local_constant_declaration_in_declaration_statement6668);
            	        	local_constant_declaration917 = local_constant_declaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_constant_declaration917.Tree);

            	        }
            	        break;

            	}

            	char_literal918=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_declaration_statement6671); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal918_tree = (object)adaptor.Create(char_literal918);
            		adaptor.AddChild(root_0, char_literal918_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 253, declaration_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "declaration_statement"

    public class local_variable_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_variable_declaration"
    // G:\\downloads\\antlr\\cs.g:912:1: local_variable_declaration : local_variable_type local_variable_declarators ;
    public csParser.local_variable_declaration_return local_variable_declaration() // throws RecognitionException [1]
    {   
        csParser.local_variable_declaration_return retval = new csParser.local_variable_declaration_return();
        retval.Start = input.LT(1);
        int local_variable_declaration_StartIndex = input.Index();
        object root_0 = null;

        csParser.local_variable_type_return local_variable_type919 = default(csParser.local_variable_type_return);

        csParser.local_variable_declarators_return local_variable_declarators920 = default(csParser.local_variable_declarators_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 254) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:912:27: ( local_variable_type local_variable_declarators )
            // G:\\downloads\\antlr\\cs.g:913:2: local_variable_type local_variable_declarators
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_local_variable_type_in_local_variable_declaration6679);
            	local_variable_type919 = local_variable_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_type919.Tree);
            	PushFollow(FOLLOW_local_variable_declarators_in_local_variable_declaration6683);
            	local_variable_declarators920 = local_variable_declarators();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declarators920.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 254, local_variable_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_variable_declaration"

    public class local_variable_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_variable_type"
    // G:\\downloads\\antlr\\cs.g:914:1: local_variable_type : ( ( 'var' )=> 'var' | ( 'dynamic' )=> 'dynamic' | type );
    public csParser.local_variable_type_return local_variable_type() // throws RecognitionException [1]
    {   
        csParser.local_variable_type_return retval = new csParser.local_variable_type_return();
        retval.Start = input.LT(1);
        int local_variable_type_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal921 = null;
        IToken string_literal922 = null;
        csParser.type_return type923 = default(csParser.type_return);


        object string_literal921_tree=null;
        object string_literal922_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 255) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:914:20: ( ( 'var' )=> 'var' | ( 'dynamic' )=> 'dynamic' | type )
            int alt245 = 3;
            switch ( input.LA(1) ) 
            {
            case 177:
            	{
                int LA245_1 = input.LA(2);

                if ( (synpred35_cs()) )
                {
                    alt245 = 1;
                }
                else if ( (true) )
                {
                    alt245 = 3;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d245s1 =
                        new NoViableAltException("", 245, 1, input);

                    throw nvae_d245s1;
                }
                }
                break;
            case 178:
            	{
                int LA245_2 = input.LA(2);

                if ( (synpred36_cs()) )
                {
                    alt245 = 2;
                }
                else if ( (true) )
                {
                    alt245 = 3;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d245s2 =
                        new NoViableAltException("", 245, 2, input);

                    throw nvae_d245s2;
                }
                }
                break;
            case IDENTIFIER:
            case 65:
            case 82:
            case 132:
            case 133:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 160:
            case 161:
            case 162:
            case 163:
            case 164:
            case 165:
            case 166:
            case 167:
            case 168:
            case 170:
            case 195:
            case 196:
            case 197:
            case 198:
            case 199:
            case 200:
            case 201:
            case 202:
            	{
                alt245 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d245s0 =
            	        new NoViableAltException("", 245, 0, input);

            	    throw nvae_d245s0;
            }

            switch (alt245) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:915:2: ( 'var' )=> 'var'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal921=(IToken)Match(input,177,FOLLOW_177_in_local_variable_type6697); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal921_tree = (object)adaptor.Create(string_literal921);
                    		adaptor.AddChild(root_0, string_literal921_tree);
                    	}

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:916:4: ( 'dynamic' )=> 'dynamic'
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	string_literal922=(IToken)Match(input,178,FOLLOW_178_in_local_variable_type6708); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{string_literal922_tree = (object)adaptor.Create(string_literal922);
                    		adaptor.AddChild(root_0, string_literal922_tree);
                    	}

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:917:4: type
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_type_in_local_variable_type6713);
                    	type923 = type();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type923.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 255, local_variable_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_variable_type"

    public class local_variable_declarators_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_variable_declarators"
    // G:\\downloads\\antlr\\cs.g:918:1: local_variable_declarators : local_variable_declarator ( ',' local_variable_declarator )* ;
    public csParser.local_variable_declarators_return local_variable_declarators() // throws RecognitionException [1]
    {   
        csParser.local_variable_declarators_return retval = new csParser.local_variable_declarators_return();
        retval.Start = input.LT(1);
        int local_variable_declarators_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal925 = null;
        csParser.local_variable_declarator_return local_variable_declarator924 = default(csParser.local_variable_declarator_return);

        csParser.local_variable_declarator_return local_variable_declarator926 = default(csParser.local_variable_declarator_return);


        object char_literal925_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 256) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:918:27: ( local_variable_declarator ( ',' local_variable_declarator )* )
            // G:\\downloads\\antlr\\cs.g:919:2: local_variable_declarator ( ',' local_variable_declarator )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_local_variable_declarator_in_local_variable_declarators6721);
            	local_variable_declarator924 = local_variable_declarator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declarator924.Tree);
            	// G:\\downloads\\antlr\\cs.g:919:28: ( ',' local_variable_declarator )*
            	do 
            	{
            	    int alt246 = 2;
            	    int LA246_0 = input.LA(1);

            	    if ( (LA246_0 == 89) )
            	    {
            	        alt246 = 1;
            	    }


            	    switch (alt246) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:919:29: ',' local_variable_declarator
            			    {
            			    	char_literal925=(IToken)Match(input,89,FOLLOW_89_in_local_variable_declarators6724); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal925_tree = (object)adaptor.Create(char_literal925);
            			    		adaptor.AddChild(root_0, char_literal925_tree);
            			    	}
            			    	PushFollow(FOLLOW_local_variable_declarator_in_local_variable_declarators6726);
            			    	local_variable_declarator926 = local_variable_declarator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declarator926.Tree);

            			    }
            			    break;

            			default:
            			    goto loop246;
            	    }
            	} while (true);

            	loop246:
            		;	// Stops C# compiler whining that label 'loop246' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 256, local_variable_declarators_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_variable_declarators"

    public class local_variable_declarator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_variable_declarator"
    // G:\\downloads\\antlr\\cs.g:920:1: local_variable_declarator : identifier ( '=' local_variable_initializer )? ;
    public csParser.local_variable_declarator_return local_variable_declarator() // throws RecognitionException [1]
    {   
        csParser.local_variable_declarator_return retval = new csParser.local_variable_declarator_return();
        retval.Start = input.LT(1);
        int local_variable_declarator_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal928 = null;
        csParser.identifier_return identifier927 = default(csParser.identifier_return);

        csParser.local_variable_initializer_return local_variable_initializer929 = default(csParser.local_variable_initializer_return);


        object char_literal928_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 257) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:920:26: ( identifier ( '=' local_variable_initializer )? )
            // G:\\downloads\\antlr\\cs.g:921:2: identifier ( '=' local_variable_initializer )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_local_variable_declarator6736);
            	identifier927 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier927.Tree);
            	// G:\\downloads\\antlr\\cs.g:921:13: ( '=' local_variable_initializer )?
            	int alt247 = 2;
            	int LA247_0 = input.LA(1);

            	if ( (LA247_0 == 66) )
            	{
            	    alt247 = 1;
            	}
            	switch (alt247) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:921:14: '=' local_variable_initializer
            	        {
            	        	char_literal928=(IToken)Match(input,66,FOLLOW_66_in_local_variable_declarator6739); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal928_tree = (object)adaptor.Create(char_literal928);
            	        		adaptor.AddChild(root_0, char_literal928_tree);
            	        	}
            	        	PushFollow(FOLLOW_local_variable_initializer_in_local_variable_declarator6743);
            	        	local_variable_initializer929 = local_variable_initializer();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_initializer929.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 257, local_variable_declarator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_variable_declarator"

    public class local_variable_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_variable_initializer"
    // G:\\downloads\\antlr\\cs.g:922:1: local_variable_initializer : ( expression | array_initializer | stackalloc_initializer );
    public csParser.local_variable_initializer_return local_variable_initializer() // throws RecognitionException [1]
    {   
        csParser.local_variable_initializer_return retval = new csParser.local_variable_initializer_return();
        retval.Start = input.LT(1);
        int local_variable_initializer_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression930 = default(csParser.expression_return);

        csParser.array_initializer_return array_initializer931 = default(csParser.array_initializer_return);

        csParser.stackalloc_initializer_return stackalloc_initializer932 = default(csParser.stackalloc_initializer_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 258) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:922:27: ( expression | array_initializer | stackalloc_initializer )
            int alt248 = 3;
            switch ( input.LA(1) ) 
            {
            case IDENTIFIER:
            case Real_literal:
            case NUMBER:
            case Hex_number:
            case Character_literal:
            case STRINGLITERAL:
            case Verbatim_string_literal:
            case TRUE:
            case FALSE:
            case NULL:
            case MINUS:
            case 65:
            case 68:
            case 83:
            case 85:
            case 88:
            case 93:
            case 94:
            case 95:
            case 96:
            case 97:
            case 98:
            case 100:
            case 102:
            case 103:
            case 104:
            case 105:
            case 106:
            case 117:
            case 132:
            case 133:
            case 135:
            case 136:
            case 137:
            case 138:
            case 139:
            case 140:
            case 141:
            case 142:
            case 143:
            case 144:
            case 145:
            case 146:
            case 147:
            case 148:
            case 150:
            case 151:
            case 152:
            case 154:
            case 157:
            case 158:
            case 159:
            case 160:
            case 161:
            case 162:
            case 163:
            case 164:
            case 165:
            case 166:
            case 167:
            case 168:
            case 170:
            case 177:
            case 178:
            case 195:
            case 196:
            case 197:
            case 198:
            case 199:
            case 200:
            case 201:
            case 202:
            	{
                alt248 = 1;
                }
                break;
            case 62:
            	{
                alt248 = 2;
                }
                break;
            case 179:
            	{
                alt248 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d248s0 =
            	        new NoViableAltException("", 248, 0, input);

            	    throw nvae_d248s0;
            }

            switch (alt248) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:923:2: expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_in_local_variable_initializer6754);
                    	expression930 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression930.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:924:4: array_initializer
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_array_initializer_in_local_variable_initializer6759);
                    	array_initializer931 = array_initializer();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, array_initializer931.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:925:4: stackalloc_initializer
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_stackalloc_initializer_in_local_variable_initializer6765);
                    	stackalloc_initializer932 = stackalloc_initializer();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, stackalloc_initializer932.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 258, local_variable_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_variable_initializer"

    public class stackalloc_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "stackalloc_initializer"
    // G:\\downloads\\antlr\\cs.g:926:1: stackalloc_initializer : 'stackalloc' unmanaged_type '[' expression ']' ;
    public csParser.stackalloc_initializer_return stackalloc_initializer() // throws RecognitionException [1]
    {   
        csParser.stackalloc_initializer_return retval = new csParser.stackalloc_initializer_return();
        retval.Start = input.LT(1);
        int stackalloc_initializer_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal933 = null;
        IToken char_literal935 = null;
        IToken char_literal937 = null;
        csParser.unmanaged_type_return unmanaged_type934 = default(csParser.unmanaged_type_return);

        csParser.expression_return expression936 = default(csParser.expression_return);


        object string_literal933_tree=null;
        object char_literal935_tree=null;
        object char_literal937_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 259) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:926:23: ( 'stackalloc' unmanaged_type '[' expression ']' )
            // G:\\downloads\\antlr\\cs.g:927:2: 'stackalloc' unmanaged_type '[' expression ']'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal933=(IToken)Match(input,179,FOLLOW_179_in_stackalloc_initializer6772); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal933_tree = (object)adaptor.Create(string_literal933);
            		adaptor.AddChild(root_0, string_literal933_tree);
            	}
            	PushFollow(FOLLOW_unmanaged_type_in_stackalloc_initializer6776);
            	unmanaged_type934 = unmanaged_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unmanaged_type934.Tree);
            	char_literal935=(IToken)Match(input,86,FOLLOW_86_in_stackalloc_initializer6780); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal935_tree = (object)adaptor.Create(char_literal935);
            		adaptor.AddChild(root_0, char_literal935_tree);
            	}
            	PushFollow(FOLLOW_expression_in_stackalloc_initializer6784);
            	expression936 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression936.Tree);
            	char_literal937=(IToken)Match(input,87,FOLLOW_87_in_stackalloc_initializer6788); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal937_tree = (object)adaptor.Create(char_literal937);
            		adaptor.AddChild(root_0, char_literal937_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 259, stackalloc_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "stackalloc_initializer"

    public class local_constant_declaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_constant_declaration"
    // G:\\downloads\\antlr\\cs.g:928:1: local_constant_declaration : 'const' type constant_declarators ;
    public csParser.local_constant_declaration_return local_constant_declaration() // throws RecognitionException [1]
    {   
        csParser.local_constant_declaration_return retval = new csParser.local_constant_declaration_return();
        retval.Start = input.LT(1);
        int local_constant_declaration_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal938 = null;
        csParser.type_return type939 = default(csParser.type_return);

        csParser.constant_declarators_return constant_declarators940 = default(csParser.constant_declarators_return);


        object string_literal938_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 260) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:928:27: ( 'const' type constant_declarators )
            // G:\\downloads\\antlr\\cs.g:929:2: 'const' type constant_declarators
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal938=(IToken)Match(input,81,FOLLOW_81_in_local_constant_declaration6796); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal938_tree = (object)adaptor.Create(string_literal938);
            		adaptor.AddChild(root_0, string_literal938_tree);
            	}
            	PushFollow(FOLLOW_type_in_local_constant_declaration6800);
            	type939 = type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type939.Tree);
            	PushFollow(FOLLOW_constant_declarators_in_local_constant_declaration6804);
            	constant_declarators940 = constant_declarators();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declarators940.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 260, local_constant_declaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_constant_declaration"

    public class expression_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "expression_statement"
    // G:\\downloads\\antlr\\cs.g:930:1: expression_statement : expression ';' ;
    public csParser.expression_statement_return expression_statement() // throws RecognitionException [1]
    {   
        csParser.expression_statement_return retval = new csParser.expression_statement_return();
        retval.Start = input.LT(1);
        int expression_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal942 = null;
        csParser.expression_return expression941 = default(csParser.expression_return);


        object char_literal942_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 261) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:930:21: ( expression ';' )
            // G:\\downloads\\antlr\\cs.g:931:2: expression ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_expression_statement6812);
            	expression941 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression941.Tree);
            	char_literal942=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_expression_statement6816); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal942_tree = (object)adaptor.Create(char_literal942);
            		adaptor.AddChild(root_0, char_literal942_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 261, expression_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expression_statement"

    public class statement_expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "statement_expression"
    // G:\\downloads\\antlr\\cs.g:934:1: statement_expression : expression ;
    public csParser.statement_expression_return statement_expression() // throws RecognitionException [1]
    {   
        csParser.statement_expression_return retval = new csParser.statement_expression_return();
        retval.Start = input.LT(1);
        int statement_expression_StartIndex = input.Index();
        object root_0 = null;

        csParser.expression_return expression943 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 262) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:934:21: ( expression )
            // G:\\downloads\\antlr\\cs.g:935:2: expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_expression_in_statement_expression6826);
            	expression943 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression943.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 262, statement_expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "statement_expression"

    public class selection_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "selection_statement"
    // G:\\downloads\\antlr\\cs.g:937:1: selection_statement : ( if_statement | switch_statement );
    public csParser.selection_statement_return selection_statement() // throws RecognitionException [1]
    {   
        csParser.selection_statement_return retval = new csParser.selection_statement_return();
        retval.Start = input.LT(1);
        int selection_statement_StartIndex = input.Index();
        object root_0 = null;

        csParser.if_statement_return if_statement944 = default(csParser.if_statement_return);

        csParser.switch_statement_return switch_statement945 = default(csParser.switch_statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 263) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:937:20: ( if_statement | switch_statement )
            int alt249 = 2;
            int LA249_0 = input.LA(1);

            if ( (LA249_0 == IF) )
            {
                alt249 = 1;
            }
            else if ( (LA249_0 == 181) )
            {
                alt249 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d249s0 =
                    new NoViableAltException("", 249, 0, input);

                throw nvae_d249s0;
            }
            switch (alt249) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:938:2: if_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_if_statement_in_selection_statement6835);
                    	if_statement944 = if_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, if_statement944.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:939:4: switch_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_switch_statement_in_selection_statement6840);
                    	switch_statement945 = switch_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_statement945.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 263, selection_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "selection_statement"

    public class if_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "if_statement"
    // G:\\downloads\\antlr\\cs.g:940:1: if_statement : 'if' '(' boolean_expression ')' embedded_statement ( ( 'else' )=> else_statement )? ;
    public csParser.if_statement_return if_statement() // throws RecognitionException [1]
    {   
        csParser.if_statement_return retval = new csParser.if_statement_return();
        retval.Start = input.LT(1);
        int if_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal946 = null;
        IToken char_literal947 = null;
        IToken char_literal949 = null;
        csParser.boolean_expression_return boolean_expression948 = default(csParser.boolean_expression_return);

        csParser.embedded_statement_return embedded_statement950 = default(csParser.embedded_statement_return);

        csParser.else_statement_return else_statement951 = default(csParser.else_statement_return);


        object string_literal946_tree=null;
        object char_literal947_tree=null;
        object char_literal949_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 264) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:940:13: ( 'if' '(' boolean_expression ')' embedded_statement ( ( 'else' )=> else_statement )? )
            // G:\\downloads\\antlr\\cs.g:942:2: 'if' '(' boolean_expression ')' embedded_statement ( ( 'else' )=> else_statement )?
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal946=(IToken)Match(input,IF,FOLLOW_IF_in_if_statement6850); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal946_tree = (object)adaptor.Create(string_literal946);
            		adaptor.AddChild(root_0, string_literal946_tree);
            	}
            	char_literal947=(IToken)Match(input,88,FOLLOW_88_in_if_statement6854); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal947_tree = (object)adaptor.Create(char_literal947);
            		adaptor.AddChild(root_0, char_literal947_tree);
            	}
            	PushFollow(FOLLOW_boolean_expression_in_if_statement6858);
            	boolean_expression948 = boolean_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression948.Tree);
            	char_literal949=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_if_statement6862); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal949_tree = (object)adaptor.Create(char_literal949);
            		adaptor.AddChild(root_0, char_literal949_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_if_statement6866);
            	embedded_statement950 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement950.Tree);
            	// G:\\downloads\\antlr\\cs.g:942:61: ( ( 'else' )=> else_statement )?
            	int alt250 = 2;
            	int LA250_0 = input.LA(1);

            	if ( (LA250_0 == 180) )
            	{
            	    int LA250_1 = input.LA(2);

            	    if ( (synpred37_cs()) )
            	    {
            	        alt250 = 1;
            	    }
            	}
            	switch (alt250) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:942:62: ( 'else' )=> else_statement
            	        {
            	        	PushFollow(FOLLOW_else_statement_in_if_statement6875);
            	        	else_statement951 = else_statement();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, else_statement951.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 264, if_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "if_statement"

    public class else_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "else_statement"
    // G:\\downloads\\antlr\\cs.g:944:1: else_statement : 'else' embedded_statement ;
    public csParser.else_statement_return else_statement() // throws RecognitionException [1]
    {   
        csParser.else_statement_return retval = new csParser.else_statement_return();
        retval.Start = input.LT(1);
        int else_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal952 = null;
        csParser.embedded_statement_return embedded_statement953 = default(csParser.embedded_statement_return);


        object string_literal952_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 265) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:944:15: ( 'else' embedded_statement )
            // G:\\downloads\\antlr\\cs.g:945:2: 'else' embedded_statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal952=(IToken)Match(input,180,FOLLOW_180_in_else_statement6886); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal952_tree = (object)adaptor.Create(string_literal952);
            		adaptor.AddChild(root_0, string_literal952_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_else_statement6890);
            	embedded_statement953 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement953.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 265, else_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "else_statement"

    public class switch_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "switch_statement"
    // G:\\downloads\\antlr\\cs.g:946:1: switch_statement : 'switch' '(' expression ')' switch_block ;
    public csParser.switch_statement_return switch_statement() // throws RecognitionException [1]
    {   
        csParser.switch_statement_return retval = new csParser.switch_statement_return();
        retval.Start = input.LT(1);
        int switch_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal954 = null;
        IToken char_literal955 = null;
        IToken char_literal957 = null;
        csParser.expression_return expression956 = default(csParser.expression_return);

        csParser.switch_block_return switch_block958 = default(csParser.switch_block_return);


        object string_literal954_tree=null;
        object char_literal955_tree=null;
        object char_literal957_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 266) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:946:17: ( 'switch' '(' expression ')' switch_block )
            // G:\\downloads\\antlr\\cs.g:947:2: 'switch' '(' expression ')' switch_block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal954=(IToken)Match(input,181,FOLLOW_181_in_switch_statement6898); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal954_tree = (object)adaptor.Create(string_literal954);
            		adaptor.AddChild(root_0, string_literal954_tree);
            	}
            	char_literal955=(IToken)Match(input,88,FOLLOW_88_in_switch_statement6902); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal955_tree = (object)adaptor.Create(char_literal955);
            		adaptor.AddChild(root_0, char_literal955_tree);
            	}
            	PushFollow(FOLLOW_expression_in_switch_statement6906);
            	expression956 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression956.Tree);
            	char_literal957=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_switch_statement6910); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal957_tree = (object)adaptor.Create(char_literal957);
            		adaptor.AddChild(root_0, char_literal957_tree);
            	}
            	PushFollow(FOLLOW_switch_block_in_switch_statement6914);
            	switch_block958 = switch_block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_block958.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 266, switch_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "switch_statement"

    public class switch_block_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "switch_block"
    // G:\\downloads\\antlr\\cs.g:948:1: switch_block : '{' ( switch_sections )? '}' ;
    public csParser.switch_block_return switch_block() // throws RecognitionException [1]
    {   
        csParser.switch_block_return retval = new csParser.switch_block_return();
        retval.Start = input.LT(1);
        int switch_block_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal959 = null;
        IToken char_literal961 = null;
        csParser.switch_sections_return switch_sections960 = default(csParser.switch_sections_return);


        object char_literal959_tree=null;
        object char_literal961_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 267) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:948:13: ( '{' ( switch_sections )? '}' )
            // G:\\downloads\\antlr\\cs.g:949:2: '{' ( switch_sections )? '}'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal959=(IToken)Match(input,62,FOLLOW_62_in_switch_block6922); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal959_tree = (object)adaptor.Create(char_literal959);
            		adaptor.AddChild(root_0, char_literal959_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:949:8: ( switch_sections )?
            	int alt251 = 2;
            	int LA251_0 = input.LA(1);

            	if ( (LA251_0 == 96 || LA251_0 == 182) )
            	{
            	    alt251 = 1;
            	}
            	switch (alt251) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:949:8: switch_sections
            	        {
            	        	PushFollow(FOLLOW_switch_sections_in_switch_block6926);
            	        	switch_sections960 = switch_sections();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_sections960.Tree);

            	        }
            	        break;

            	}

            	char_literal961=(IToken)Match(input,63,FOLLOW_63_in_switch_block6931); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal961_tree = (object)adaptor.Create(char_literal961);
            		adaptor.AddChild(root_0, char_literal961_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 267, switch_block_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "switch_block"

    public class switch_sections_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "switch_sections"
    // G:\\downloads\\antlr\\cs.g:950:1: switch_sections : ( switch_section )+ ;
    public csParser.switch_sections_return switch_sections() // throws RecognitionException [1]
    {   
        csParser.switch_sections_return retval = new csParser.switch_sections_return();
        retval.Start = input.LT(1);
        int switch_sections_StartIndex = input.Index();
        object root_0 = null;

        csParser.switch_section_return switch_section962 = default(csParser.switch_section_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 268) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:950:16: ( ( switch_section )+ )
            // G:\\downloads\\antlr\\cs.g:951:2: ( switch_section )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:951:2: ( switch_section )+
            	int cnt252 = 0;
            	do 
            	{
            	    int alt252 = 2;
            	    int LA252_0 = input.LA(1);

            	    if ( (LA252_0 == 96 || LA252_0 == 182) )
            	    {
            	        alt252 = 1;
            	    }


            	    switch (alt252) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:951:2: switch_section
            			    {
            			    	PushFollow(FOLLOW_switch_section_in_switch_sections6939);
            			    	switch_section962 = switch_section();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_section962.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt252 >= 1 ) goto loop252;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(252, input);
            		            throw eee;
            	    }
            	    cnt252++;
            	} while (true);

            	loop252:
            		;	// Stops C# compiler whinging that label 'loop252' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 268, switch_sections_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "switch_sections"

    public class switch_section_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "switch_section"
    // G:\\downloads\\antlr\\cs.g:952:1: switch_section : switch_labels statement_list ;
    public csParser.switch_section_return switch_section() // throws RecognitionException [1]
    {   
        csParser.switch_section_return retval = new csParser.switch_section_return();
        retval.Start = input.LT(1);
        int switch_section_StartIndex = input.Index();
        object root_0 = null;

        csParser.switch_labels_return switch_labels963 = default(csParser.switch_labels_return);

        csParser.statement_list_return statement_list964 = default(csParser.statement_list_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 269) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:952:15: ( switch_labels statement_list )
            // G:\\downloads\\antlr\\cs.g:953:2: switch_labels statement_list
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_switch_labels_in_switch_section6948);
            	switch_labels963 = switch_labels();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_labels963.Tree);
            	PushFollow(FOLLOW_statement_list_in_switch_section6952);
            	statement_list964 = statement_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_list964.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 269, switch_section_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "switch_section"

    public class switch_labels_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "switch_labels"
    // G:\\downloads\\antlr\\cs.g:954:1: switch_labels : ( switch_label )+ ;
    public csParser.switch_labels_return switch_labels() // throws RecognitionException [1]
    {   
        csParser.switch_labels_return retval = new csParser.switch_labels_return();
        retval.Start = input.LT(1);
        int switch_labels_StartIndex = input.Index();
        object root_0 = null;

        csParser.switch_label_return switch_label965 = default(csParser.switch_label_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 270) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:954:14: ( ( switch_label )+ )
            // G:\\downloads\\antlr\\cs.g:955:2: ( switch_label )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:955:2: ( switch_label )+
            	int cnt253 = 0;
            	do 
            	{
            	    int alt253 = 2;
            	    int LA253_0 = input.LA(1);

            	    if ( (LA253_0 == 96) )
            	    {
            	        int LA253_2 = input.LA(2);

            	        if ( (LA253_2 == 90) )
            	        {
            	            alt253 = 1;
            	        }


            	    }
            	    else if ( (LA253_0 == 182) )
            	    {
            	        alt253 = 1;
            	    }


            	    switch (alt253) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:955:2: switch_label
            			    {
            			    	PushFollow(FOLLOW_switch_label_in_switch_labels6960);
            			    	switch_label965 = switch_label();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, switch_label965.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt253 >= 1 ) goto loop253;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(253, input);
            		            throw eee;
            	    }
            	    cnt253++;
            	} while (true);

            	loop253:
            		;	// Stops C# compiler whinging that label 'loop253' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 270, switch_labels_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "switch_labels"

    public class switch_label_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "switch_label"
    // G:\\downloads\\antlr\\cs.g:956:1: switch_label : ( ( 'case' constant_expression ':' ) | ( 'default' ':' ) );
    public csParser.switch_label_return switch_label() // throws RecognitionException [1]
    {   
        csParser.switch_label_return retval = new csParser.switch_label_return();
        retval.Start = input.LT(1);
        int switch_label_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal966 = null;
        IToken char_literal968 = null;
        IToken string_literal969 = null;
        IToken char_literal970 = null;
        csParser.constant_expression_return constant_expression967 = default(csParser.constant_expression_return);


        object string_literal966_tree=null;
        object char_literal968_tree=null;
        object string_literal969_tree=null;
        object char_literal970_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 271) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:956:13: ( ( 'case' constant_expression ':' ) | ( 'default' ':' ) )
            int alt254 = 2;
            int LA254_0 = input.LA(1);

            if ( (LA254_0 == 182) )
            {
                alt254 = 1;
            }
            else if ( (LA254_0 == 96) )
            {
                alt254 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d254s0 =
                    new NoViableAltException("", 254, 0, input);

                throw nvae_d254s0;
            }
            switch (alt254) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:957:2: ( 'case' constant_expression ':' )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:957:2: ( 'case' constant_expression ':' )
                    	// G:\\downloads\\antlr\\cs.g:957:3: 'case' constant_expression ':'
                    	{
                    		string_literal966=(IToken)Match(input,182,FOLLOW_182_in_switch_label6970); if (state.failed) return retval;
                    		if ( state.backtracking == 0 )
                    		{string_literal966_tree = (object)adaptor.Create(string_literal966);
                    			adaptor.AddChild(root_0, string_literal966_tree);
                    		}
                    		PushFollow(FOLLOW_constant_expression_in_switch_label6974);
                    		constant_expression967 = constant_expression();
                    		state.followingStackPointer--;
                    		if (state.failed) return retval;
                    		if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_expression967.Tree);
                    		char_literal968=(IToken)Match(input,90,FOLLOW_90_in_switch_label6978); if (state.failed) return retval;
                    		if ( state.backtracking == 0 )
                    		{char_literal968_tree = (object)adaptor.Create(char_literal968);
                    			adaptor.AddChild(root_0, char_literal968_tree);
                    		}

                    	}


                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:958:4: ( 'default' ':' )
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	// G:\\downloads\\antlr\\cs.g:958:4: ( 'default' ':' )
                    	// G:\\downloads\\antlr\\cs.g:958:5: 'default' ':'
                    	{
                    		string_literal969=(IToken)Match(input,96,FOLLOW_96_in_switch_label6985); if (state.failed) return retval;
                    		if ( state.backtracking == 0 )
                    		{string_literal969_tree = (object)adaptor.Create(string_literal969);
                    			adaptor.AddChild(root_0, string_literal969_tree);
                    		}
                    		char_literal970=(IToken)Match(input,90,FOLLOW_90_in_switch_label6989); if (state.failed) return retval;
                    		if ( state.backtracking == 0 )
                    		{char_literal970_tree = (object)adaptor.Create(char_literal970);
                    			adaptor.AddChild(root_0, char_literal970_tree);
                    		}

                    	}


                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 271, switch_label_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "switch_label"

    public class iteration_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "iteration_statement"
    // G:\\downloads\\antlr\\cs.g:959:1: iteration_statement : ( while_statement | do_statement | for_statement | foreach_statement );
    public csParser.iteration_statement_return iteration_statement() // throws RecognitionException [1]
    {   
        csParser.iteration_statement_return retval = new csParser.iteration_statement_return();
        retval.Start = input.LT(1);
        int iteration_statement_StartIndex = input.Index();
        object root_0 = null;

        csParser.while_statement_return while_statement971 = default(csParser.while_statement_return);

        csParser.do_statement_return do_statement972 = default(csParser.do_statement_return);

        csParser.for_statement_return for_statement973 = default(csParser.for_statement_return);

        csParser.foreach_statement_return foreach_statement974 = default(csParser.foreach_statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 272) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:959:20: ( while_statement | do_statement | for_statement | foreach_statement )
            int alt255 = 4;
            switch ( input.LA(1) ) 
            {
            case 183:
            	{
                alt255 = 1;
                }
                break;
            case 184:
            	{
                alt255 = 2;
                }
                break;
            case 185:
            	{
                alt255 = 3;
                }
                break;
            case 186:
            	{
                alt255 = 4;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d255s0 =
            	        new NoViableAltException("", 255, 0, input);

            	    throw nvae_d255s0;
            }

            switch (alt255) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:960:2: while_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_while_statement_in_iteration_statement6998);
                    	while_statement971 = while_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, while_statement971.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:961:4: do_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_do_statement_in_iteration_statement7003);
                    	do_statement972 = do_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, do_statement972.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:962:4: for_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_for_statement_in_iteration_statement7008);
                    	for_statement973 = for_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_statement973.Tree);

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:963:4: foreach_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_foreach_statement_in_iteration_statement7013);
                    	foreach_statement974 = foreach_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, foreach_statement974.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 272, iteration_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "iteration_statement"

    public class while_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "while_statement"
    // G:\\downloads\\antlr\\cs.g:964:1: while_statement : 'while' '(' boolean_expression ')' embedded_statement ;
    public csParser.while_statement_return while_statement() // throws RecognitionException [1]
    {   
        csParser.while_statement_return retval = new csParser.while_statement_return();
        retval.Start = input.LT(1);
        int while_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal975 = null;
        IToken char_literal976 = null;
        IToken char_literal978 = null;
        csParser.boolean_expression_return boolean_expression977 = default(csParser.boolean_expression_return);

        csParser.embedded_statement_return embedded_statement979 = default(csParser.embedded_statement_return);


        object string_literal975_tree=null;
        object char_literal976_tree=null;
        object char_literal978_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 273) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:964:16: ( 'while' '(' boolean_expression ')' embedded_statement )
            // G:\\downloads\\antlr\\cs.g:965:2: 'while' '(' boolean_expression ')' embedded_statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal975=(IToken)Match(input,183,FOLLOW_183_in_while_statement7021); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal975_tree = (object)adaptor.Create(string_literal975);
            		adaptor.AddChild(root_0, string_literal975_tree);
            	}
            	char_literal976=(IToken)Match(input,88,FOLLOW_88_in_while_statement7025); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal976_tree = (object)adaptor.Create(char_literal976);
            		adaptor.AddChild(root_0, char_literal976_tree);
            	}
            	PushFollow(FOLLOW_boolean_expression_in_while_statement7029);
            	boolean_expression977 = boolean_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression977.Tree);
            	char_literal978=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_while_statement7033); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal978_tree = (object)adaptor.Create(char_literal978);
            		adaptor.AddChild(root_0, char_literal978_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_while_statement7037);
            	embedded_statement979 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement979.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 273, while_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "while_statement"

    public class do_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "do_statement"
    // G:\\downloads\\antlr\\cs.g:966:1: do_statement : 'do' embedded_statement 'while' '(' boolean_expression ')' ';' ;
    public csParser.do_statement_return do_statement() // throws RecognitionException [1]
    {   
        csParser.do_statement_return retval = new csParser.do_statement_return();
        retval.Start = input.LT(1);
        int do_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal980 = null;
        IToken string_literal982 = null;
        IToken char_literal983 = null;
        IToken char_literal985 = null;
        IToken char_literal986 = null;
        csParser.embedded_statement_return embedded_statement981 = default(csParser.embedded_statement_return);

        csParser.boolean_expression_return boolean_expression984 = default(csParser.boolean_expression_return);


        object string_literal980_tree=null;
        object string_literal982_tree=null;
        object char_literal983_tree=null;
        object char_literal985_tree=null;
        object char_literal986_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 274) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:966:13: ( 'do' embedded_statement 'while' '(' boolean_expression ')' ';' )
            // G:\\downloads\\antlr\\cs.g:967:2: 'do' embedded_statement 'while' '(' boolean_expression ')' ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal980=(IToken)Match(input,184,FOLLOW_184_in_do_statement7045); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal980_tree = (object)adaptor.Create(string_literal980);
            		adaptor.AddChild(root_0, string_literal980_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_do_statement7049);
            	embedded_statement981 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement981.Tree);
            	string_literal982=(IToken)Match(input,183,FOLLOW_183_in_do_statement7053); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal982_tree = (object)adaptor.Create(string_literal982);
            		adaptor.AddChild(root_0, string_literal982_tree);
            	}
            	char_literal983=(IToken)Match(input,88,FOLLOW_88_in_do_statement7057); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal983_tree = (object)adaptor.Create(char_literal983);
            		adaptor.AddChild(root_0, char_literal983_tree);
            	}
            	PushFollow(FOLLOW_boolean_expression_in_do_statement7061);
            	boolean_expression984 = boolean_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression984.Tree);
            	char_literal985=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_do_statement7065); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal985_tree = (object)adaptor.Create(char_literal985);
            		adaptor.AddChild(root_0, char_literal985_tree);
            	}
            	char_literal986=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_do_statement7069); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal986_tree = (object)adaptor.Create(char_literal986);
            		adaptor.AddChild(root_0, char_literal986_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 274, do_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "do_statement"

    public class for_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "for_statement"
    // G:\\downloads\\antlr\\cs.g:968:1: for_statement : 'for' '(' ( for_initializer )? ';' ( for_condition )? ';' ( for_iterator )? ')' embedded_statement ;
    public csParser.for_statement_return for_statement() // throws RecognitionException [1]
    {   
        csParser.for_statement_return retval = new csParser.for_statement_return();
        retval.Start = input.LT(1);
        int for_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal987 = null;
        IToken char_literal988 = null;
        IToken char_literal990 = null;
        IToken char_literal992 = null;
        IToken char_literal994 = null;
        csParser.for_initializer_return for_initializer989 = default(csParser.for_initializer_return);

        csParser.for_condition_return for_condition991 = default(csParser.for_condition_return);

        csParser.for_iterator_return for_iterator993 = default(csParser.for_iterator_return);

        csParser.embedded_statement_return embedded_statement995 = default(csParser.embedded_statement_return);


        object string_literal987_tree=null;
        object char_literal988_tree=null;
        object char_literal990_tree=null;
        object char_literal992_tree=null;
        object char_literal994_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 275) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:968:14: ( 'for' '(' ( for_initializer )? ';' ( for_condition )? ';' ( for_iterator )? ')' embedded_statement )
            // G:\\downloads\\antlr\\cs.g:969:2: 'for' '(' ( for_initializer )? ';' ( for_condition )? ';' ( for_iterator )? ')' embedded_statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal987=(IToken)Match(input,185,FOLLOW_185_in_for_statement7077); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal987_tree = (object)adaptor.Create(string_literal987);
            		adaptor.AddChild(root_0, string_literal987_tree);
            	}
            	char_literal988=(IToken)Match(input,88,FOLLOW_88_in_for_statement7081); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal988_tree = (object)adaptor.Create(char_literal988);
            		adaptor.AddChild(root_0, char_literal988_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:969:16: ( for_initializer )?
            	int alt256 = 2;
            	int LA256_0 = input.LA(1);

            	if ( ((LA256_0 >= IDENTIFIER && LA256_0 <= NULL) || LA256_0 == MINUS || LA256_0 == 65 || LA256_0 == 68 || (LA256_0 >= 82 && LA256_0 <= 83) || LA256_0 == 85 || LA256_0 == 88 || (LA256_0 >= 93 && LA256_0 <= 98) || LA256_0 == 100 || (LA256_0 >= 102 && LA256_0 <= 106) || LA256_0 == 117 || (LA256_0 >= 132 && LA256_0 <= 133) || (LA256_0 >= 135 && LA256_0 <= 148) || (LA256_0 >= 150 && LA256_0 <= 152) || LA256_0 == 154 || (LA256_0 >= 157 && LA256_0 <= 168) || LA256_0 == 170 || (LA256_0 >= 177 && LA256_0 <= 178) || (LA256_0 >= 195 && LA256_0 <= 202)) )
            	{
            	    alt256 = 1;
            	}
            	switch (alt256) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:969:16: for_initializer
            	        {
            	        	PushFollow(FOLLOW_for_initializer_in_for_statement7085);
            	        	for_initializer989 = for_initializer();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_initializer989.Tree);

            	        }
            	        break;

            	}

            	char_literal990=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_for_statement7090); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal990_tree = (object)adaptor.Create(char_literal990);
            		adaptor.AddChild(root_0, char_literal990_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:969:41: ( for_condition )?
            	int alt257 = 2;
            	int LA257_0 = input.LA(1);

            	if ( ((LA257_0 >= IDENTIFIER && LA257_0 <= NULL) || LA257_0 == MINUS || LA257_0 == 65 || LA257_0 == 68 || LA257_0 == 83 || LA257_0 == 85 || LA257_0 == 88 || (LA257_0 >= 93 && LA257_0 <= 98) || LA257_0 == 100 || (LA257_0 >= 102 && LA257_0 <= 106) || LA257_0 == 117 || (LA257_0 >= 132 && LA257_0 <= 133) || (LA257_0 >= 135 && LA257_0 <= 148) || (LA257_0 >= 150 && LA257_0 <= 152) || LA257_0 == 154 || (LA257_0 >= 157 && LA257_0 <= 168) || LA257_0 == 170 || (LA257_0 >= 177 && LA257_0 <= 178) || (LA257_0 >= 195 && LA257_0 <= 202)) )
            	{
            	    alt257 = 1;
            	}
            	switch (alt257) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:969:41: for_condition
            	        {
            	        	PushFollow(FOLLOW_for_condition_in_for_statement7094);
            	        	for_condition991 = for_condition();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_condition991.Tree);

            	        }
            	        break;

            	}

            	char_literal992=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_for_statement7099); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal992_tree = (object)adaptor.Create(char_literal992);
            		adaptor.AddChild(root_0, char_literal992_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:969:64: ( for_iterator )?
            	int alt258 = 2;
            	int LA258_0 = input.LA(1);

            	if ( ((LA258_0 >= IDENTIFIER && LA258_0 <= NULL) || LA258_0 == MINUS || LA258_0 == 65 || LA258_0 == 68 || LA258_0 == 83 || LA258_0 == 85 || LA258_0 == 88 || (LA258_0 >= 93 && LA258_0 <= 98) || LA258_0 == 100 || (LA258_0 >= 102 && LA258_0 <= 106) || LA258_0 == 117 || (LA258_0 >= 132 && LA258_0 <= 133) || (LA258_0 >= 135 && LA258_0 <= 148) || (LA258_0 >= 150 && LA258_0 <= 152) || LA258_0 == 154 || (LA258_0 >= 157 && LA258_0 <= 168) || LA258_0 == 170 || (LA258_0 >= 177 && LA258_0 <= 178) || (LA258_0 >= 195 && LA258_0 <= 202)) )
            	{
            	    alt258 = 1;
            	}
            	switch (alt258) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:969:64: for_iterator
            	        {
            	        	PushFollow(FOLLOW_for_iterator_in_for_statement7103);
            	        	for_iterator993 = for_iterator();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, for_iterator993.Tree);

            	        }
            	        break;

            	}

            	char_literal994=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_for_statement7108); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal994_tree = (object)adaptor.Create(char_literal994);
            		adaptor.AddChild(root_0, char_literal994_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_for_statement7112);
            	embedded_statement995 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement995.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 275, for_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "for_statement"

    public class for_initializer_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "for_initializer"
    // G:\\downloads\\antlr\\cs.g:970:1: for_initializer : ( ( local_variable_declaration )=> local_variable_declaration | statement_expression_list );
    public csParser.for_initializer_return for_initializer() // throws RecognitionException [1]
    {   
        csParser.for_initializer_return retval = new csParser.for_initializer_return();
        retval.Start = input.LT(1);
        int for_initializer_StartIndex = input.Index();
        object root_0 = null;

        csParser.local_variable_declaration_return local_variable_declaration996 = default(csParser.local_variable_declaration_return);

        csParser.statement_expression_list_return statement_expression_list997 = default(csParser.statement_expression_list_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 276) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:970:16: ( ( local_variable_declaration )=> local_variable_declaration | statement_expression_list )
            int alt259 = 2;
            alt259 = dfa259.Predict(input);
            switch (alt259) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:971:2: ( local_variable_declaration )=> local_variable_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_local_variable_declaration_in_for_initializer7126);
                    	local_variable_declaration996 = local_variable_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration996.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:972:4: statement_expression_list
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_statement_expression_list_in_for_initializer7131);
                    	statement_expression_list997 = statement_expression_list();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression_list997.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 276, for_initializer_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "for_initializer"

    public class for_condition_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "for_condition"
    // G:\\downloads\\antlr\\cs.g:974:1: for_condition : boolean_expression ;
    public csParser.for_condition_return for_condition() // throws RecognitionException [1]
    {   
        csParser.for_condition_return retval = new csParser.for_condition_return();
        retval.Start = input.LT(1);
        int for_condition_StartIndex = input.Index();
        object root_0 = null;

        csParser.boolean_expression_return boolean_expression998 = default(csParser.boolean_expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 277) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:974:14: ( boolean_expression )
            // G:\\downloads\\antlr\\cs.g:975:2: boolean_expression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_boolean_expression_in_for_condition7141);
            	boolean_expression998 = boolean_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, boolean_expression998.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 277, for_condition_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "for_condition"

    public class for_iterator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "for_iterator"
    // G:\\downloads\\antlr\\cs.g:976:1: for_iterator : statement_expression_list ;
    public csParser.for_iterator_return for_iterator() // throws RecognitionException [1]
    {   
        csParser.for_iterator_return retval = new csParser.for_iterator_return();
        retval.Start = input.LT(1);
        int for_iterator_StartIndex = input.Index();
        object root_0 = null;

        csParser.statement_expression_list_return statement_expression_list999 = default(csParser.statement_expression_list_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 278) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:976:13: ( statement_expression_list )
            // G:\\downloads\\antlr\\cs.g:977:2: statement_expression_list
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_statement_expression_list_in_for_iterator7149);
            	statement_expression_list999 = statement_expression_list();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression_list999.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 278, for_iterator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "for_iterator"

    public class statement_expression_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "statement_expression_list"
    // G:\\downloads\\antlr\\cs.g:978:1: statement_expression_list : statement_expression ( ',' statement_expression )* ;
    public csParser.statement_expression_list_return statement_expression_list() // throws RecognitionException [1]
    {   
        csParser.statement_expression_list_return retval = new csParser.statement_expression_list_return();
        retval.Start = input.LT(1);
        int statement_expression_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1001 = null;
        csParser.statement_expression_return statement_expression1000 = default(csParser.statement_expression_return);

        csParser.statement_expression_return statement_expression1002 = default(csParser.statement_expression_return);


        object char_literal1001_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 279) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:978:26: ( statement_expression ( ',' statement_expression )* )
            // G:\\downloads\\antlr\\cs.g:979:2: statement_expression ( ',' statement_expression )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_statement_expression_in_statement_expression_list7157);
            	statement_expression1000 = statement_expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression1000.Tree);
            	// G:\\downloads\\antlr\\cs.g:979:23: ( ',' statement_expression )*
            	do 
            	{
            	    int alt260 = 2;
            	    int LA260_0 = input.LA(1);

            	    if ( (LA260_0 == 89) )
            	    {
            	        alt260 = 1;
            	    }


            	    switch (alt260) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:979:24: ',' statement_expression
            			    {
            			    	char_literal1001=(IToken)Match(input,89,FOLLOW_89_in_statement_expression_list7160); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1001_tree = (object)adaptor.Create(char_literal1001);
            			    		adaptor.AddChild(root_0, char_literal1001_tree);
            			    	}
            			    	PushFollow(FOLLOW_statement_expression_in_statement_expression_list7162);
            			    	statement_expression1002 = statement_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, statement_expression1002.Tree);

            			    }
            			    break;

            			default:
            			    goto loop260;
            	    }
            	} while (true);

            	loop260:
            		;	// Stops C# compiler whining that label 'loop260' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 279, statement_expression_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "statement_expression_list"

    public class foreach_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "foreach_statement"
    // G:\\downloads\\antlr\\cs.g:980:1: foreach_statement : 'foreach' '(' local_variable_type identifier 'in' expression ')' embedded_statement ;
    public csParser.foreach_statement_return foreach_statement() // throws RecognitionException [1]
    {   
        csParser.foreach_statement_return retval = new csParser.foreach_statement_return();
        retval.Start = input.LT(1);
        int foreach_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1003 = null;
        IToken char_literal1004 = null;
        IToken string_literal1007 = null;
        IToken char_literal1009 = null;
        csParser.local_variable_type_return local_variable_type1005 = default(csParser.local_variable_type_return);

        csParser.identifier_return identifier1006 = default(csParser.identifier_return);

        csParser.expression_return expression1008 = default(csParser.expression_return);

        csParser.embedded_statement_return embedded_statement1010 = default(csParser.embedded_statement_return);


        object string_literal1003_tree=null;
        object char_literal1004_tree=null;
        object string_literal1007_tree=null;
        object char_literal1009_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 280) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:980:18: ( 'foreach' '(' local_variable_type identifier 'in' expression ')' embedded_statement )
            // G:\\downloads\\antlr\\cs.g:981:2: 'foreach' '(' local_variable_type identifier 'in' expression ')' embedded_statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1003=(IToken)Match(input,186,FOLLOW_186_in_foreach_statement7172); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1003_tree = (object)adaptor.Create(string_literal1003);
            		adaptor.AddChild(root_0, string_literal1003_tree);
            	}
            	char_literal1004=(IToken)Match(input,88,FOLLOW_88_in_foreach_statement7176); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1004_tree = (object)adaptor.Create(char_literal1004);
            		adaptor.AddChild(root_0, char_literal1004_tree);
            	}
            	PushFollow(FOLLOW_local_variable_type_in_foreach_statement7180);
            	local_variable_type1005 = local_variable_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_type1005.Tree);
            	PushFollow(FOLLOW_identifier_in_foreach_statement7184);
            	identifier1006 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier1006.Tree);
            	string_literal1007=(IToken)Match(input,134,FOLLOW_134_in_foreach_statement7188); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1007_tree = (object)adaptor.Create(string_literal1007);
            		adaptor.AddChild(root_0, string_literal1007_tree);
            	}
            	PushFollow(FOLLOW_expression_in_foreach_statement7192);
            	expression1008 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1008.Tree);
            	char_literal1009=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_foreach_statement7196); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1009_tree = (object)adaptor.Create(char_literal1009);
            		adaptor.AddChild(root_0, char_literal1009_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_foreach_statement7200);
            	embedded_statement1010 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement1010.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 280, foreach_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "foreach_statement"

    public class jump_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "jump_statement"
    // G:\\downloads\\antlr\\cs.g:982:1: jump_statement : ( break_statement | continue_statement | goto_statement | return_statement | throw_statement );
    public csParser.jump_statement_return jump_statement() // throws RecognitionException [1]
    {   
        csParser.jump_statement_return retval = new csParser.jump_statement_return();
        retval.Start = input.LT(1);
        int jump_statement_StartIndex = input.Index();
        object root_0 = null;

        csParser.break_statement_return break_statement1011 = default(csParser.break_statement_return);

        csParser.continue_statement_return continue_statement1012 = default(csParser.continue_statement_return);

        csParser.goto_statement_return goto_statement1013 = default(csParser.goto_statement_return);

        csParser.return_statement_return return_statement1014 = default(csParser.return_statement_return);

        csParser.throw_statement_return throw_statement1015 = default(csParser.throw_statement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 281) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:982:15: ( break_statement | continue_statement | goto_statement | return_statement | throw_statement )
            int alt261 = 5;
            switch ( input.LA(1) ) 
            {
            case 187:
            	{
                alt261 = 1;
                }
                break;
            case 188:
            	{
                alt261 = 2;
                }
                break;
            case 189:
            	{
                alt261 = 3;
                }
                break;
            case 153:
            	{
                alt261 = 4;
                }
                break;
            case 190:
            	{
                alt261 = 5;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d261s0 =
            	        new NoViableAltException("", 261, 0, input);

            	    throw nvae_d261s0;
            }

            switch (alt261) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:983:2: break_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_break_statement_in_jump_statement7208);
                    	break_statement1011 = break_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, break_statement1011.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:984:4: continue_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_continue_statement_in_jump_statement7213);
                    	continue_statement1012 = continue_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, continue_statement1012.Tree);

                    }
                    break;
                case 3 :
                    // G:\\downloads\\antlr\\cs.g:985:4: goto_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_goto_statement_in_jump_statement7218);
                    	goto_statement1013 = goto_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, goto_statement1013.Tree);

                    }
                    break;
                case 4 :
                    // G:\\downloads\\antlr\\cs.g:986:4: return_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_return_statement_in_jump_statement7223);
                    	return_statement1014 = return_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, return_statement1014.Tree);

                    }
                    break;
                case 5 :
                    // G:\\downloads\\antlr\\cs.g:987:4: throw_statement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_throw_statement_in_jump_statement7228);
                    	throw_statement1015 = throw_statement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, throw_statement1015.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 281, jump_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "jump_statement"

    public class break_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "break_statement"
    // G:\\downloads\\antlr\\cs.g:988:1: break_statement : 'break' ';' ;
    public csParser.break_statement_return break_statement() // throws RecognitionException [1]
    {   
        csParser.break_statement_return retval = new csParser.break_statement_return();
        retval.Start = input.LT(1);
        int break_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1016 = null;
        IToken char_literal1017 = null;

        object string_literal1016_tree=null;
        object char_literal1017_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 282) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:988:16: ( 'break' ';' )
            // G:\\downloads\\antlr\\cs.g:989:2: 'break' ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1016=(IToken)Match(input,187,FOLLOW_187_in_break_statement7236); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1016_tree = (object)adaptor.Create(string_literal1016);
            		adaptor.AddChild(root_0, string_literal1016_tree);
            	}
            	char_literal1017=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_break_statement7240); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1017_tree = (object)adaptor.Create(char_literal1017);
            		adaptor.AddChild(root_0, char_literal1017_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 282, break_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "break_statement"

    public class continue_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "continue_statement"
    // G:\\downloads\\antlr\\cs.g:990:1: continue_statement : 'continue' ';' ;
    public csParser.continue_statement_return continue_statement() // throws RecognitionException [1]
    {   
        csParser.continue_statement_return retval = new csParser.continue_statement_return();
        retval.Start = input.LT(1);
        int continue_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1018 = null;
        IToken char_literal1019 = null;

        object string_literal1018_tree=null;
        object char_literal1019_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 283) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:990:19: ( 'continue' ';' )
            // G:\\downloads\\antlr\\cs.g:991:2: 'continue' ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1018=(IToken)Match(input,188,FOLLOW_188_in_continue_statement7248); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1018_tree = (object)adaptor.Create(string_literal1018);
            		adaptor.AddChild(root_0, string_literal1018_tree);
            	}
            	char_literal1019=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_continue_statement7252); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1019_tree = (object)adaptor.Create(char_literal1019);
            		adaptor.AddChild(root_0, char_literal1019_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 283, continue_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "continue_statement"

    public class goto_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "goto_statement"
    // G:\\downloads\\antlr\\cs.g:992:1: goto_statement : 'goto' ( identifier | 'case' constant_expression | 'default' ) ';' ;
    public csParser.goto_statement_return goto_statement() // throws RecognitionException [1]
    {   
        csParser.goto_statement_return retval = new csParser.goto_statement_return();
        retval.Start = input.LT(1);
        int goto_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1020 = null;
        IToken string_literal1022 = null;
        IToken string_literal1024 = null;
        IToken char_literal1025 = null;
        csParser.identifier_return identifier1021 = default(csParser.identifier_return);

        csParser.constant_expression_return constant_expression1023 = default(csParser.constant_expression_return);


        object string_literal1020_tree=null;
        object string_literal1022_tree=null;
        object string_literal1024_tree=null;
        object char_literal1025_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 284) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:992:15: ( 'goto' ( identifier | 'case' constant_expression | 'default' ) ';' )
            // G:\\downloads\\antlr\\cs.g:993:2: 'goto' ( identifier | 'case' constant_expression | 'default' ) ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1020=(IToken)Match(input,189,FOLLOW_189_in_goto_statement7260); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1020_tree = (object)adaptor.Create(string_literal1020);
            		adaptor.AddChild(root_0, string_literal1020_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:993:11: ( identifier | 'case' constant_expression | 'default' )
            	int alt262 = 3;
            	switch ( input.LA(1) ) 
            	{
            	case IDENTIFIER:
            	case 65:
            	case 132:
            	case 133:
            	case 135:
            	case 136:
            	case 137:
            	case 138:
            	case 139:
            	case 140:
            	case 141:
            	case 142:
            	case 143:
            	case 144:
            	case 145:
            	case 146:
            	case 147:
            	case 148:
            	case 150:
            	case 151:
            	case 152:
            	case 154:
            	case 157:
            	case 158:
            	case 159:
            	case 170:
            	case 177:
            	case 178:
            	case 195:
            	case 202:
            		{
            	    alt262 = 1;
            	    }
            	    break;
            	case 182:
            		{
            	    alt262 = 2;
            	    }
            	    break;
            	case 96:
            		{
            	    alt262 = 3;
            	    }
            	    break;
            		default:
            		    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		    NoViableAltException nvae_d262s0 =
            		        new NoViableAltException("", 262, 0, input);

            		    throw nvae_d262s0;
            	}

            	switch (alt262) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:993:13: identifier
            	        {
            	        	PushFollow(FOLLOW_identifier_in_goto_statement7266);
            	        	identifier1021 = identifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier1021.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:994:7: 'case' constant_expression
            	        {
            	        	string_literal1022=(IToken)Match(input,182,FOLLOW_182_in_goto_statement7274); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal1022_tree = (object)adaptor.Create(string_literal1022);
            	        		adaptor.AddChild(root_0, string_literal1022_tree);
            	        	}
            	        	PushFollow(FOLLOW_constant_expression_in_goto_statement7278);
            	        	constant_expression1023 = constant_expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_expression1023.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // G:\\downloads\\antlr\\cs.g:995:7: 'default'
            	        {
            	        	string_literal1024=(IToken)Match(input,96,FOLLOW_96_in_goto_statement7286); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal1024_tree = (object)adaptor.Create(string_literal1024);
            	        		adaptor.AddChild(root_0, string_literal1024_tree);
            	        	}

            	        }
            	        break;

            	}

            	char_literal1025=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_goto_statement7291); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1025_tree = (object)adaptor.Create(char_literal1025);
            		adaptor.AddChild(root_0, char_literal1025_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 284, goto_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "goto_statement"

    public class return_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "return_statement"
    // G:\\downloads\\antlr\\cs.g:996:1: return_statement : 'return' ( expression )? ';' ;
    public csParser.return_statement_return return_statement() // throws RecognitionException [1]
    {   
        csParser.return_statement_return retval = new csParser.return_statement_return();
        retval.Start = input.LT(1);
        int return_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1026 = null;
        IToken char_literal1028 = null;
        csParser.expression_return expression1027 = default(csParser.expression_return);


        object string_literal1026_tree=null;
        object char_literal1028_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 285) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:996:17: ( 'return' ( expression )? ';' )
            // G:\\downloads\\antlr\\cs.g:997:2: 'return' ( expression )? ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1026=(IToken)Match(input,153,FOLLOW_153_in_return_statement7299); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1026_tree = (object)adaptor.Create(string_literal1026);
            		adaptor.AddChild(root_0, string_literal1026_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:997:13: ( expression )?
            	int alt263 = 2;
            	int LA263_0 = input.LA(1);

            	if ( ((LA263_0 >= IDENTIFIER && LA263_0 <= NULL) || LA263_0 == MINUS || LA263_0 == 65 || LA263_0 == 68 || LA263_0 == 83 || LA263_0 == 85 || LA263_0 == 88 || (LA263_0 >= 93 && LA263_0 <= 98) || LA263_0 == 100 || (LA263_0 >= 102 && LA263_0 <= 106) || LA263_0 == 117 || (LA263_0 >= 132 && LA263_0 <= 133) || (LA263_0 >= 135 && LA263_0 <= 148) || (LA263_0 >= 150 && LA263_0 <= 152) || LA263_0 == 154 || (LA263_0 >= 157 && LA263_0 <= 168) || LA263_0 == 170 || (LA263_0 >= 177 && LA263_0 <= 178) || (LA263_0 >= 195 && LA263_0 <= 202)) )
            	{
            	    alt263 = 1;
            	}
            	switch (alt263) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:997:13: expression
            	        {
            	        	PushFollow(FOLLOW_expression_in_return_statement7303);
            	        	expression1027 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1027.Tree);

            	        }
            	        break;

            	}

            	char_literal1028=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_return_statement7308); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1028_tree = (object)adaptor.Create(char_literal1028);
            		adaptor.AddChild(root_0, char_literal1028_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 285, return_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "return_statement"

    public class throw_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "throw_statement"
    // G:\\downloads\\antlr\\cs.g:998:1: throw_statement : 'throw' ( expression )? ';' ;
    public csParser.throw_statement_return throw_statement() // throws RecognitionException [1]
    {   
        csParser.throw_statement_return retval = new csParser.throw_statement_return();
        retval.Start = input.LT(1);
        int throw_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1029 = null;
        IToken char_literal1031 = null;
        csParser.expression_return expression1030 = default(csParser.expression_return);


        object string_literal1029_tree=null;
        object char_literal1031_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 286) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:998:16: ( 'throw' ( expression )? ';' )
            // G:\\downloads\\antlr\\cs.g:999:2: 'throw' ( expression )? ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1029=(IToken)Match(input,190,FOLLOW_190_in_throw_statement7316); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1029_tree = (object)adaptor.Create(string_literal1029);
            		adaptor.AddChild(root_0, string_literal1029_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:999:12: ( expression )?
            	int alt264 = 2;
            	int LA264_0 = input.LA(1);

            	if ( ((LA264_0 >= IDENTIFIER && LA264_0 <= NULL) || LA264_0 == MINUS || LA264_0 == 65 || LA264_0 == 68 || LA264_0 == 83 || LA264_0 == 85 || LA264_0 == 88 || (LA264_0 >= 93 && LA264_0 <= 98) || LA264_0 == 100 || (LA264_0 >= 102 && LA264_0 <= 106) || LA264_0 == 117 || (LA264_0 >= 132 && LA264_0 <= 133) || (LA264_0 >= 135 && LA264_0 <= 148) || (LA264_0 >= 150 && LA264_0 <= 152) || LA264_0 == 154 || (LA264_0 >= 157 && LA264_0 <= 168) || LA264_0 == 170 || (LA264_0 >= 177 && LA264_0 <= 178) || (LA264_0 >= 195 && LA264_0 <= 202)) )
            	{
            	    alt264 = 1;
            	}
            	switch (alt264) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:999:12: expression
            	        {
            	        	PushFollow(FOLLOW_expression_in_throw_statement7320);
            	        	expression1030 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1030.Tree);

            	        }
            	        break;

            	}

            	char_literal1031=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_throw_statement7325); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1031_tree = (object)adaptor.Create(char_literal1031);
            		adaptor.AddChild(root_0, char_literal1031_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 286, throw_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "throw_statement"

    public class try_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "try_statement"
    // G:\\downloads\\antlr\\cs.g:1000:1: try_statement : 'try' block ( catch_clauses ( finally_clause )? | finally_clause ) ;
    public csParser.try_statement_return try_statement() // throws RecognitionException [1]
    {   
        csParser.try_statement_return retval = new csParser.try_statement_return();
        retval.Start = input.LT(1);
        int try_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1032 = null;
        csParser.block_return block1033 = default(csParser.block_return);

        csParser.catch_clauses_return catch_clauses1034 = default(csParser.catch_clauses_return);

        csParser.finally_clause_return finally_clause1035 = default(csParser.finally_clause_return);

        csParser.finally_clause_return finally_clause1036 = default(csParser.finally_clause_return);


        object string_literal1032_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 287) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1000:14: ( 'try' block ( catch_clauses ( finally_clause )? | finally_clause ) )
            // G:\\downloads\\antlr\\cs.g:1001:7: 'try' block ( catch_clauses ( finally_clause )? | finally_clause )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1032=(IToken)Match(input,191,FOLLOW_191_in_try_statement7338); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1032_tree = (object)adaptor.Create(string_literal1032);
            		adaptor.AddChild(root_0, string_literal1032_tree);
            	}
            	PushFollow(FOLLOW_block_in_try_statement7342);
            	block1033 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1033.Tree);
            	// G:\\downloads\\antlr\\cs.g:1001:23: ( catch_clauses ( finally_clause )? | finally_clause )
            	int alt266 = 2;
            	int LA266_0 = input.LA(1);

            	if ( (LA266_0 == 192) )
            	{
            	    alt266 = 1;
            	}
            	else if ( (LA266_0 == 193) )
            	{
            	    alt266 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d266s0 =
            	        new NoViableAltException("", 266, 0, input);

            	    throw nvae_d266s0;
            	}
            	switch (alt266) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:1001:25: catch_clauses ( finally_clause )?
            	        {
            	        	PushFollow(FOLLOW_catch_clauses_in_try_statement7348);
            	        	catch_clauses1034 = catch_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, catch_clauses1034.Tree);
            	        	// G:\\downloads\\antlr\\cs.g:1001:41: ( finally_clause )?
            	        	int alt265 = 2;
            	        	int LA265_0 = input.LA(1);

            	        	if ( (LA265_0 == 193) )
            	        	{
            	        	    alt265 = 1;
            	        	}
            	        	switch (alt265) 
            	        	{
            	        	    case 1 :
            	        	        // G:\\downloads\\antlr\\cs.g:1001:41: finally_clause
            	        	        {
            	        	        	PushFollow(FOLLOW_finally_clause_in_try_statement7352);
            	        	        	finally_clause1035 = finally_clause();
            	        	        	state.followingStackPointer--;
            	        	        	if (state.failed) return retval;
            	        	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, finally_clause1035.Tree);

            	        	        }
            	        	        break;

            	        	}


            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:1002:10: finally_clause
            	        {
            	        	PushFollow(FOLLOW_finally_clause_in_try_statement7364);
            	        	finally_clause1036 = finally_clause();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, finally_clause1036.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 287, try_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "try_statement"

    public class catch_clauses_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "catch_clauses"
    // G:\\downloads\\antlr\\cs.g:1004:1: catch_clauses : 'catch' ( specific_catch_clauses | general_catch_clause ) ;
    public csParser.catch_clauses_return catch_clauses() // throws RecognitionException [1]
    {   
        csParser.catch_clauses_return retval = new csParser.catch_clauses_return();
        retval.Start = input.LT(1);
        int catch_clauses_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1037 = null;
        csParser.specific_catch_clauses_return specific_catch_clauses1038 = default(csParser.specific_catch_clauses_return);

        csParser.general_catch_clause_return general_catch_clause1039 = default(csParser.general_catch_clause_return);


        object string_literal1037_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 288) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1004:14: ( 'catch' ( specific_catch_clauses | general_catch_clause ) )
            // G:\\downloads\\antlr\\cs.g:1005:2: 'catch' ( specific_catch_clauses | general_catch_clause )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1037=(IToken)Match(input,192,FOLLOW_192_in_catch_clauses7373); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1037_tree = (object)adaptor.Create(string_literal1037);
            		adaptor.AddChild(root_0, string_literal1037_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:1005:12: ( specific_catch_clauses | general_catch_clause )
            	int alt267 = 2;
            	int LA267_0 = input.LA(1);

            	if ( (LA267_0 == 88) )
            	{
            	    alt267 = 1;
            	}
            	else if ( (LA267_0 == SEMI || LA267_0 == 62) )
            	{
            	    alt267 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d267s0 =
            	        new NoViableAltException("", 267, 0, input);

            	    throw nvae_d267s0;
            	}
            	switch (alt267) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:1005:13: specific_catch_clauses
            	        {
            	        	PushFollow(FOLLOW_specific_catch_clauses_in_catch_clauses7378);
            	        	specific_catch_clauses1038 = specific_catch_clauses();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, specific_catch_clauses1038.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:1005:38: general_catch_clause
            	        {
            	        	PushFollow(FOLLOW_general_catch_clause_in_catch_clauses7382);
            	        	general_catch_clause1039 = general_catch_clause();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, general_catch_clause1039.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 288, catch_clauses_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "catch_clauses"

    public class specific_catch_clauses_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "specific_catch_clauses"
    // G:\\downloads\\antlr\\cs.g:1006:1: specific_catch_clauses : specific_catch_clause ( 'catch' ( specific_catch_clause | general_catch_clause ) )* ;
    public csParser.specific_catch_clauses_return specific_catch_clauses() // throws RecognitionException [1]
    {   
        csParser.specific_catch_clauses_return retval = new csParser.specific_catch_clauses_return();
        retval.Start = input.LT(1);
        int specific_catch_clauses_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1041 = null;
        csParser.specific_catch_clause_return specific_catch_clause1040 = default(csParser.specific_catch_clause_return);

        csParser.specific_catch_clause_return specific_catch_clause1042 = default(csParser.specific_catch_clause_return);

        csParser.general_catch_clause_return general_catch_clause1043 = default(csParser.general_catch_clause_return);


        object string_literal1041_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 289) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1006:23: ( specific_catch_clause ( 'catch' ( specific_catch_clause | general_catch_clause ) )* )
            // G:\\downloads\\antlr\\cs.g:1007:2: specific_catch_clause ( 'catch' ( specific_catch_clause | general_catch_clause ) )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_specific_catch_clause_in_specific_catch_clauses7391);
            	specific_catch_clause1040 = specific_catch_clause();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, specific_catch_clause1040.Tree);
            	// G:\\downloads\\antlr\\cs.g:1007:26: ( 'catch' ( specific_catch_clause | general_catch_clause ) )*
            	do 
            	{
            	    int alt269 = 2;
            	    int LA269_0 = input.LA(1);

            	    if ( (LA269_0 == 192) )
            	    {
            	        alt269 = 1;
            	    }


            	    switch (alt269) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1007:27: 'catch' ( specific_catch_clause | general_catch_clause )
            			    {
            			    	string_literal1041=(IToken)Match(input,192,FOLLOW_192_in_specific_catch_clauses7396); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{string_literal1041_tree = (object)adaptor.Create(string_literal1041);
            			    		adaptor.AddChild(root_0, string_literal1041_tree);
            			    	}
            			    	// G:\\downloads\\antlr\\cs.g:1007:37: ( specific_catch_clause | general_catch_clause )
            			    	int alt268 = 2;
            			    	int LA268_0 = input.LA(1);

            			    	if ( (LA268_0 == 88) )
            			    	{
            			    	    alt268 = 1;
            			    	}
            			    	else if ( (LA268_0 == SEMI || LA268_0 == 62) )
            			    	{
            			    	    alt268 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d268s0 =
            			    	        new NoViableAltException("", 268, 0, input);

            			    	    throw nvae_d268s0;
            			    	}
            			    	switch (alt268) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1007:38: specific_catch_clause
            			    	        {
            			    	        	PushFollow(FOLLOW_specific_catch_clause_in_specific_catch_clauses7401);
            			    	        	specific_catch_clause1042 = specific_catch_clause();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, specific_catch_clause1042.Tree);

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // G:\\downloads\\antlr\\cs.g:1007:62: general_catch_clause
            			    	        {
            			    	        	PushFollow(FOLLOW_general_catch_clause_in_specific_catch_clauses7405);
            			    	        	general_catch_clause1043 = general_catch_clause();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, general_catch_clause1043.Tree);

            			    	        }
            			    	        break;

            			    	}


            			    }
            			    break;

            			default:
            			    goto loop269;
            	    }
            	} while (true);

            	loop269:
            		;	// Stops C# compiler whining that label 'loop269' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 289, specific_catch_clauses_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "specific_catch_clauses"

    public class specific_catch_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "specific_catch_clause"
    // G:\\downloads\\antlr\\cs.g:1008:1: specific_catch_clause : '(' class_type ( identifier )? ')' block ;
    public csParser.specific_catch_clause_return specific_catch_clause() // throws RecognitionException [1]
    {   
        csParser.specific_catch_clause_return retval = new csParser.specific_catch_clause_return();
        retval.Start = input.LT(1);
        int specific_catch_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1044 = null;
        IToken char_literal1047 = null;
        csParser.class_type_return class_type1045 = default(csParser.class_type_return);

        csParser.identifier_return identifier1046 = default(csParser.identifier_return);

        csParser.block_return block1048 = default(csParser.block_return);


        object char_literal1044_tree=null;
        object char_literal1047_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 290) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1008:22: ( '(' class_type ( identifier )? ')' block )
            // G:\\downloads\\antlr\\cs.g:1009:2: '(' class_type ( identifier )? ')' block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	char_literal1044=(IToken)Match(input,88,FOLLOW_88_in_specific_catch_clause7415); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1044_tree = (object)adaptor.Create(char_literal1044);
            		adaptor.AddChild(root_0, char_literal1044_tree);
            	}
            	PushFollow(FOLLOW_class_type_in_specific_catch_clause7419);
            	class_type1045 = class_type();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, class_type1045.Tree);
            	// G:\\downloads\\antlr\\cs.g:1009:21: ( identifier )?
            	int alt270 = 2;
            	int LA270_0 = input.LA(1);

            	if ( (LA270_0 == IDENTIFIER || LA270_0 == 65 || (LA270_0 >= 132 && LA270_0 <= 133) || (LA270_0 >= 135 && LA270_0 <= 148) || (LA270_0 >= 150 && LA270_0 <= 152) || LA270_0 == 154 || (LA270_0 >= 157 && LA270_0 <= 159) || LA270_0 == 170 || (LA270_0 >= 177 && LA270_0 <= 178) || LA270_0 == 195 || LA270_0 == 202) )
            	{
            	    alt270 = 1;
            	}
            	switch (alt270) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:1009:21: identifier
            	        {
            	        	PushFollow(FOLLOW_identifier_in_specific_catch_clause7423);
            	        	identifier1046 = identifier();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier1046.Tree);

            	        }
            	        break;

            	}

            	char_literal1047=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_specific_catch_clause7428); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1047_tree = (object)adaptor.Create(char_literal1047);
            		adaptor.AddChild(root_0, char_literal1047_tree);
            	}
            	PushFollow(FOLLOW_block_in_specific_catch_clause7432);
            	block1048 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1048.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 290, specific_catch_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "specific_catch_clause"

    public class general_catch_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "general_catch_clause"
    // G:\\downloads\\antlr\\cs.g:1010:1: general_catch_clause : block ;
    public csParser.general_catch_clause_return general_catch_clause() // throws RecognitionException [1]
    {   
        csParser.general_catch_clause_return retval = new csParser.general_catch_clause_return();
        retval.Start = input.LT(1);
        int general_catch_clause_StartIndex = input.Index();
        object root_0 = null;

        csParser.block_return block1049 = default(csParser.block_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 291) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1010:21: ( block )
            // G:\\downloads\\antlr\\cs.g:1011:2: block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_block_in_general_catch_clause7440);
            	block1049 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1049.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 291, general_catch_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "general_catch_clause"

    public class finally_clause_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "finally_clause"
    // G:\\downloads\\antlr\\cs.g:1012:1: finally_clause : 'finally' block ;
    public csParser.finally_clause_return finally_clause() // throws RecognitionException [1]
    {   
        csParser.finally_clause_return retval = new csParser.finally_clause_return();
        retval.Start = input.LT(1);
        int finally_clause_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1050 = null;
        csParser.block_return block1051 = default(csParser.block_return);


        object string_literal1050_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 292) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1012:15: ( 'finally' block )
            // G:\\downloads\\antlr\\cs.g:1013:2: 'finally' block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1050=(IToken)Match(input,193,FOLLOW_193_in_finally_clause7448); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1050_tree = (object)adaptor.Create(string_literal1050);
            		adaptor.AddChild(root_0, string_literal1050_tree);
            	}
            	PushFollow(FOLLOW_block_in_finally_clause7452);
            	block1051 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1051.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 292, finally_clause_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "finally_clause"

    public class checked_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "checked_statement"
    // G:\\downloads\\antlr\\cs.g:1014:1: checked_statement : 'checked' block ;
    public csParser.checked_statement_return checked_statement() // throws RecognitionException [1]
    {   
        csParser.checked_statement_return retval = new csParser.checked_statement_return();
        retval.Start = input.LT(1);
        int checked_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1052 = null;
        csParser.block_return block1053 = default(csParser.block_return);


        object string_literal1052_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 293) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1014:18: ( 'checked' block )
            // G:\\downloads\\antlr\\cs.g:1015:2: 'checked' block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1052=(IToken)Match(input,94,FOLLOW_94_in_checked_statement7460); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1052_tree = (object)adaptor.Create(string_literal1052);
            		adaptor.AddChild(root_0, string_literal1052_tree);
            	}
            	PushFollow(FOLLOW_block_in_checked_statement7464);
            	block1053 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1053.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 293, checked_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "checked_statement"

    public class unchecked_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unchecked_statement"
    // G:\\downloads\\antlr\\cs.g:1016:1: unchecked_statement : 'unchecked' block ;
    public csParser.unchecked_statement_return unchecked_statement() // throws RecognitionException [1]
    {   
        csParser.unchecked_statement_return retval = new csParser.unchecked_statement_return();
        retval.Start = input.LT(1);
        int unchecked_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1054 = null;
        csParser.block_return block1055 = default(csParser.block_return);


        object string_literal1054_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 294) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1016:20: ( 'unchecked' block )
            // G:\\downloads\\antlr\\cs.g:1017:2: 'unchecked' block
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1054=(IToken)Match(input,95,FOLLOW_95_in_unchecked_statement7472); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1054_tree = (object)adaptor.Create(string_literal1054);
            		adaptor.AddChild(root_0, string_literal1054_tree);
            	}
            	PushFollow(FOLLOW_block_in_unchecked_statement7476);
            	block1055 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, block1055.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 294, unchecked_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unchecked_statement"

    public class lock_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "lock_statement"
    // G:\\downloads\\antlr\\cs.g:1018:1: lock_statement : 'lock' '(' expression ')' embedded_statement ;
    public csParser.lock_statement_return lock_statement() // throws RecognitionException [1]
    {   
        csParser.lock_statement_return retval = new csParser.lock_statement_return();
        retval.Start = input.LT(1);
        int lock_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1056 = null;
        IToken char_literal1057 = null;
        IToken char_literal1059 = null;
        csParser.expression_return expression1058 = default(csParser.expression_return);

        csParser.embedded_statement_return embedded_statement1060 = default(csParser.embedded_statement_return);


        object string_literal1056_tree=null;
        object char_literal1057_tree=null;
        object char_literal1059_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 295) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1018:15: ( 'lock' '(' expression ')' embedded_statement )
            // G:\\downloads\\antlr\\cs.g:1019:2: 'lock' '(' expression ')' embedded_statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1056=(IToken)Match(input,194,FOLLOW_194_in_lock_statement7484); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1056_tree = (object)adaptor.Create(string_literal1056);
            		adaptor.AddChild(root_0, string_literal1056_tree);
            	}
            	char_literal1057=(IToken)Match(input,88,FOLLOW_88_in_lock_statement7488); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1057_tree = (object)adaptor.Create(char_literal1057);
            		adaptor.AddChild(root_0, char_literal1057_tree);
            	}
            	PushFollow(FOLLOW_expression_in_lock_statement7491);
            	expression1058 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1058.Tree);
            	char_literal1059=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_lock_statement7495); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1059_tree = (object)adaptor.Create(char_literal1059);
            		adaptor.AddChild(root_0, char_literal1059_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_lock_statement7499);
            	embedded_statement1060 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement1060.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 295, lock_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "lock_statement"

    public class using_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "using_statement"
    // G:\\downloads\\antlr\\cs.g:1020:1: using_statement : 'using' '(' resource_acquisition ')' embedded_statement ;
    public csParser.using_statement_return using_statement() // throws RecognitionException [1]
    {   
        csParser.using_statement_return retval = new csParser.using_statement_return();
        retval.Start = input.LT(1);
        int using_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1061 = null;
        IToken char_literal1062 = null;
        IToken char_literal1064 = null;
        csParser.resource_acquisition_return resource_acquisition1063 = default(csParser.resource_acquisition_return);

        csParser.embedded_statement_return embedded_statement1065 = default(csParser.embedded_statement_return);


        object string_literal1061_tree=null;
        object char_literal1062_tree=null;
        object char_literal1064_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 296) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1020:16: ( 'using' '(' resource_acquisition ')' embedded_statement )
            // G:\\downloads\\antlr\\cs.g:1021:2: 'using' '(' resource_acquisition ')' embedded_statement
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1061=(IToken)Match(input,USING,FOLLOW_USING_in_using_statement7507); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1061_tree = (object)adaptor.Create(string_literal1061);
            		adaptor.AddChild(root_0, string_literal1061_tree);
            	}
            	char_literal1062=(IToken)Match(input,88,FOLLOW_88_in_using_statement7511); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1062_tree = (object)adaptor.Create(char_literal1062);
            		adaptor.AddChild(root_0, char_literal1062_tree);
            	}
            	PushFollow(FOLLOW_resource_acquisition_in_using_statement7516);
            	resource_acquisition1063 = resource_acquisition();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, resource_acquisition1063.Tree);
            	char_literal1064=(IToken)Match(input,RPAREN,FOLLOW_RPAREN_in_using_statement7520); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{char_literal1064_tree = (object)adaptor.Create(char_literal1064);
            		adaptor.AddChild(root_0, char_literal1064_tree);
            	}
            	PushFollow(FOLLOW_embedded_statement_in_using_statement7525);
            	embedded_statement1065 = embedded_statement();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, embedded_statement1065.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 296, using_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "using_statement"

    public class resource_acquisition_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "resource_acquisition"
    // G:\\downloads\\antlr\\cs.g:1022:1: resource_acquisition : ( ( local_variable_declaration )=> local_variable_declaration | expression );
    public csParser.resource_acquisition_return resource_acquisition() // throws RecognitionException [1]
    {   
        csParser.resource_acquisition_return retval = new csParser.resource_acquisition_return();
        retval.Start = input.LT(1);
        int resource_acquisition_StartIndex = input.Index();
        object root_0 = null;

        csParser.local_variable_declaration_return local_variable_declaration1066 = default(csParser.local_variable_declaration_return);

        csParser.expression_return expression1067 = default(csParser.expression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 297) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1022:21: ( ( local_variable_declaration )=> local_variable_declaration | expression )
            int alt271 = 2;
            alt271 = dfa271.Predict(input);
            switch (alt271) 
            {
                case 1 :
                    // G:\\downloads\\antlr\\cs.g:1023:2: ( local_variable_declaration )=> local_variable_declaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_local_variable_declaration_in_resource_acquisition7539);
                    	local_variable_declaration1066 = local_variable_declaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration1066.Tree);

                    }
                    break;
                case 2 :
                    // G:\\downloads\\antlr\\cs.g:1024:4: expression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expression_in_resource_acquisition7544);
                    	expression1067 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1067.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 297, resource_acquisition_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "resource_acquisition"

    public class yield_statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "yield_statement"
    // G:\\downloads\\antlr\\cs.g:1025:1: yield_statement : 'yield' ( 'return' expression ';' | 'break' ';' ) ;
    public csParser.yield_statement_return yield_statement() // throws RecognitionException [1]
    {   
        csParser.yield_statement_return retval = new csParser.yield_statement_return();
        retval.Start = input.LT(1);
        int yield_statement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1068 = null;
        IToken string_literal1069 = null;
        IToken char_literal1071 = null;
        IToken string_literal1072 = null;
        IToken char_literal1073 = null;
        csParser.expression_return expression1070 = default(csParser.expression_return);


        object string_literal1068_tree=null;
        object string_literal1069_tree=null;
        object char_literal1071_tree=null;
        object string_literal1072_tree=null;
        object char_literal1073_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 298) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1025:16: ( 'yield' ( 'return' expression ';' | 'break' ';' ) )
            // G:\\downloads\\antlr\\cs.g:1026:2: 'yield' ( 'return' expression ';' | 'break' ';' )
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal1068=(IToken)Match(input,195,FOLLOW_195_in_yield_statement7552); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal1068_tree = (object)adaptor.Create(string_literal1068);
            		adaptor.AddChild(root_0, string_literal1068_tree);
            	}
            	// G:\\downloads\\antlr\\cs.g:1026:12: ( 'return' expression ';' | 'break' ';' )
            	int alt272 = 2;
            	int LA272_0 = input.LA(1);

            	if ( (LA272_0 == 153) )
            	{
            	    alt272 = 1;
            	}
            	else if ( (LA272_0 == 187) )
            	{
            	    alt272 = 2;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d272s0 =
            	        new NoViableAltException("", 272, 0, input);

            	    throw nvae_d272s0;
            	}
            	switch (alt272) 
            	{
            	    case 1 :
            	        // G:\\downloads\\antlr\\cs.g:1026:13: 'return' expression ';'
            	        {
            	        	string_literal1069=(IToken)Match(input,153,FOLLOW_153_in_yield_statement7557); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal1069_tree = (object)adaptor.Create(string_literal1069);
            	        		adaptor.AddChild(root_0, string_literal1069_tree);
            	        	}
            	        	PushFollow(FOLLOW_expression_in_yield_statement7561);
            	        	expression1070 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1070.Tree);
            	        	char_literal1071=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_yield_statement7565); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal1071_tree = (object)adaptor.Create(char_literal1071);
            	        		adaptor.AddChild(root_0, char_literal1071_tree);
            	        	}

            	        }
            	        break;
            	    case 2 :
            	        // G:\\downloads\\antlr\\cs.g:1027:14: 'break' ';'
            	        {
            	        	string_literal1072=(IToken)Match(input,187,FOLLOW_187_in_yield_statement7580); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{string_literal1072_tree = (object)adaptor.Create(string_literal1072);
            	        		adaptor.AddChild(root_0, string_literal1072_tree);
            	        	}
            	        	char_literal1073=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_yield_statement7584); if (state.failed) return retval;
            	        	if ( state.backtracking == 0 )
            	        	{char_literal1073_tree = (object)adaptor.Create(char_literal1073);
            	        		adaptor.AddChild(root_0, char_literal1073_tree);
            	        	}

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 298, yield_statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "yield_statement"

    public class predefined_type_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "predefined_type"
    // G:\\downloads\\antlr\\cs.g:1033:1: predefined_type : ( 'bool' | 'byte' | 'char' | 'decimal' | 'double' | 'float' | 'int' | 'long' | 'object' | 'sbyte' | 'short' | 'string' | 'uint' | 'ulong' | 'ushort' );
    public csParser.predefined_type_return predefined_type() // throws RecognitionException [1]
    {   
        csParser.predefined_type_return retval = new csParser.predefined_type_return();
        retval.Start = input.LT(1);
        int predefined_type_StartIndex = input.Index();
        object root_0 = null;

        IToken set1074 = null;

        object set1074_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 299) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1033:16: ( 'bool' | 'byte' | 'char' | 'decimal' | 'double' | 'float' | 'int' | 'long' | 'object' | 'sbyte' | 'short' | 'string' | 'uint' | 'ulong' | 'ushort' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set1074 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 160 && input.LA(1) <= 168) || (input.LA(1) >= 196 && input.LA(1) <= 201) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1074));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 299, predefined_type_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "predefined_type"

    public class identifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "identifier"
    // G:\\downloads\\antlr\\cs.g:1037:1: identifier : ( IDENTIFIER | 'add' | 'alias' | 'assembly' | 'module' | 'field' | 'method' | 'param' | 'property' | 'type' | 'yield' | 'from' | 'into' | 'join' | 'on' | 'where' | 'orderby' | 'group' | 'by' | 'ascending' | 'descending' | 'equals' | 'select' | 'pragma' | 'let' | 'remove' | 'set' | 'var' | '__arglist' | 'dynamic' );
    public csParser.identifier_return identifier() // throws RecognitionException [1]
    {   
        csParser.identifier_return retval = new csParser.identifier_return();
        retval.Start = input.LT(1);
        int identifier_StartIndex = input.Index();
        object root_0 = null;

        IToken set1075 = null;

        object set1075_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 300) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1037:11: ( IDENTIFIER | 'add' | 'alias' | 'assembly' | 'module' | 'field' | 'method' | 'param' | 'property' | 'type' | 'yield' | 'from' | 'into' | 'join' | 'on' | 'where' | 'orderby' | 'group' | 'by' | 'ascending' | 'descending' | 'equals' | 'select' | 'pragma' | 'let' | 'remove' | 'set' | 'var' | '__arglist' | 'dynamic' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set1075 = (IToken)input.LT(1);
            	if ( input.LA(1) == IDENTIFIER || input.LA(1) == 65 || (input.LA(1) >= 132 && input.LA(1) <= 133) || (input.LA(1) >= 135 && input.LA(1) <= 148) || (input.LA(1) >= 150 && input.LA(1) <= 152) || input.LA(1) == 154 || (input.LA(1) >= 157 && input.LA(1) <= 159) || input.LA(1) == 170 || (input.LA(1) >= 177 && input.LA(1) <= 178) || input.LA(1) == 195 || input.LA(1) == 202 ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1075));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 300, identifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "identifier"

    public class keyword_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "keyword"
    // G:\\downloads\\antlr\\cs.g:1041:1: keyword : ( 'abstract' | 'as' | 'base' | 'bool' | 'break' | 'byte' | 'case' | 'catch' | 'char' | 'checked' | 'class' | 'const' | 'continue' | 'decimal' | 'default' | 'delegate' | 'do' | 'double' | 'else' | 'enum' | 'event' | 'explicit' | 'extern' | 'false' | 'finally' | 'fixed' | 'float' | 'for' | 'foreach' | 'goto' | 'if' | 'implicit' | 'in' | 'int' | 'interface' | 'internal' | 'is' | 'lock' | 'long' | 'namespace' | 'new' | 'null' | 'object' | 'operator' | 'out' | 'override' | 'params' | 'private' | 'protected' | 'public' | 'readonly' | 'ref' | 'return' | 'sbyte' | 'sealed' | 'short' | 'sizeof' | 'stackalloc' | 'static' | 'string' | 'struct' | 'switch' | 'this' | 'throw' | 'true' | 'try' | 'typeof' | 'uint' | 'ulong' | 'unchecked' | 'unsafe' | 'ushort' | 'using' | 'virtual' | 'void' | 'volatile' );
    public csParser.keyword_return keyword() // throws RecognitionException [1]
    {   
        csParser.keyword_return retval = new csParser.keyword_return();
        retval.Start = input.LT(1);
        int keyword_StartIndex = input.Index();
        object root_0 = null;

        IToken set1076 = null;

        object set1076_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 301) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1041:8: ( 'abstract' | 'as' | 'base' | 'bool' | 'break' | 'byte' | 'case' | 'catch' | 'char' | 'checked' | 'class' | 'const' | 'continue' | 'decimal' | 'default' | 'delegate' | 'do' | 'double' | 'else' | 'enum' | 'event' | 'explicit' | 'extern' | 'false' | 'finally' | 'fixed' | 'float' | 'for' | 'foreach' | 'goto' | 'if' | 'implicit' | 'in' | 'int' | 'interface' | 'internal' | 'is' | 'lock' | 'long' | 'namespace' | 'new' | 'null' | 'object' | 'operator' | 'out' | 'override' | 'params' | 'private' | 'protected' | 'public' | 'readonly' | 'ref' | 'return' | 'sbyte' | 'sealed' | 'short' | 'sizeof' | 'stackalloc' | 'static' | 'string' | 'struct' | 'switch' | 'this' | 'throw' | 'true' | 'try' | 'typeof' | 'uint' | 'ulong' | 'unchecked' | 'unsafe' | 'ushort' | 'using' | 'virtual' | 'void' | 'volatile' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set1076 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= TRUE && input.LA(1) <= NULL) || (input.LA(1) >= USING && input.LA(1) <= IF) || input.LA(1) == 61 || input.LA(1) == 64 || (input.LA(1) >= 68 && input.LA(1) <= 83) || input.LA(1) == 85 || (input.LA(1) >= 91 && input.LA(1) <= 98) || (input.LA(1) >= 122 && input.LA(1) <= 123) || input.LA(1) == 134 || input.LA(1) == 149 || input.LA(1) == 153 || input.LA(1) == 155 || (input.LA(1) >= 160 && input.LA(1) <= 169) || (input.LA(1) >= 171 && input.LA(1) <= 176) || (input.LA(1) >= 179 && input.LA(1) <= 182) || (input.LA(1) >= 184 && input.LA(1) <= 194) || (input.LA(1) >= 196 && input.LA(1) <= 201) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1076));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 301, keyword_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "keyword"

    public class also_keyword_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "also_keyword"
    // G:\\downloads\\antlr\\cs.g:1044:1: also_keyword : ( 'add' | 'alias' | 'assembly' | 'module' | 'field' | 'event' | 'method' | 'param' | 'property' | 'type' | 'yield' | 'from' | 'into' | 'join' | 'on' | 'where' | 'orderby' | 'group' | 'by' | 'ascending' | 'descending' | 'equals' | 'select' | 'pragma' | 'let' | 'remove' | 'set' | 'var' | '__arglist' | 'dynamic' );
    public csParser.also_keyword_return also_keyword() // throws RecognitionException [1]
    {   
        csParser.also_keyword_return retval = new csParser.also_keyword_return();
        retval.Start = input.LT(1);
        int also_keyword_StartIndex = input.Index();
        object root_0 = null;

        IToken set1077 = null;

        object set1077_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 302) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1044:13: ( 'add' | 'alias' | 'assembly' | 'module' | 'field' | 'event' | 'method' | 'param' | 'property' | 'type' | 'yield' | 'from' | 'into' | 'join' | 'on' | 'where' | 'orderby' | 'group' | 'by' | 'ascending' | 'descending' | 'equals' | 'select' | 'pragma' | 'let' | 'remove' | 'set' | 'var' | '__arglist' | 'dynamic' )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set1077 = (IToken)input.LT(1);
            	if ( input.LA(1) == 65 || (input.LA(1) >= 132 && input.LA(1) <= 133) || (input.LA(1) >= 135 && input.LA(1) <= 152) || input.LA(1) == 154 || (input.LA(1) >= 157 && input.LA(1) <= 159) || input.LA(1) == 170 || (input.LA(1) >= 177 && input.LA(1) <= 178) || input.LA(1) == 195 || input.LA(1) == 202 ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1077));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 302, also_keyword_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "also_keyword"

    public class literal_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "literal"
    // G:\\downloads\\antlr\\cs.g:1049:1: literal : ( Real_literal | NUMBER | Hex_number | Character_literal | STRINGLITERAL | Verbatim_string_literal | TRUE | FALSE | NULL );
    public csParser.literal_return literal() // throws RecognitionException [1]
    {   
        csParser.literal_return retval = new csParser.literal_return();
        retval.Start = input.LT(1);
        int literal_StartIndex = input.Index();
        object root_0 = null;

        IToken set1078 = null;

        object set1078_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 303) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1049:8: ( Real_literal | NUMBER | Hex_number | Character_literal | STRINGLITERAL | Verbatim_string_literal | TRUE | FALSE | NULL )
            // G:\\downloads\\antlr\\cs.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set1078 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= Real_literal && input.LA(1) <= NULL) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set1078));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 303, literal_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "literal"

    public class assignment_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "assignment_list"
    // G:\\downloads\\antlr\\cs.g:1330:1: assignment_list : ( assignment ';' )+ ;
    public csParser.assignment_list_return assignment_list() // throws RecognitionException [1]
    {   
        csParser.assignment_list_return retval = new csParser.assignment_list_return();
        retval.Start = input.LT(1);
        int assignment_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1080 = null;
        csParser.assignment_return assignment1079 = default(csParser.assignment_return);


        object char_literal1080_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 304) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1330:16: ( ( assignment ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1331:2: ( assignment ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1331:2: ( assignment ';' )+
            	int cnt273 = 0;
            	do 
            	{
            	    int alt273 = 2;
            	    int LA273_0 = input.LA(1);

            	    if ( ((LA273_0 >= IDENTIFIER && LA273_0 <= NULL) || LA273_0 == MINUS || LA273_0 == 65 || LA273_0 == 68 || LA273_0 == 83 || LA273_0 == 85 || LA273_0 == 88 || (LA273_0 >= 93 && LA273_0 <= 98) || LA273_0 == 100 || (LA273_0 >= 102 && LA273_0 <= 106) || LA273_0 == 117 || (LA273_0 >= 132 && LA273_0 <= 133) || (LA273_0 >= 135 && LA273_0 <= 148) || (LA273_0 >= 150 && LA273_0 <= 152) || LA273_0 == 154 || (LA273_0 >= 157 && LA273_0 <= 168) || LA273_0 == 170 || (LA273_0 >= 177 && LA273_0 <= 178) || (LA273_0 >= 195 && LA273_0 <= 202)) )
            	    {
            	        alt273 = 1;
            	    }


            	    switch (alt273) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1331:3: assignment ';'
            			    {
            			    	PushFollow(FOLLOW_assignment_in_assignment_list10280);
            			    	assignment1079 = assignment();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignment1079.Tree);
            			    	char_literal1080=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_assignment_list10282); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1080_tree = (object)adaptor.Create(char_literal1080);
            			    		adaptor.AddChild(root_0, char_literal1080_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt273 >= 1 ) goto loop273;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(273, input);
            		            throw eee;
            	    }
            	    cnt273++;
            	} while (true);

            	loop273:
            		;	// Stops C# compiler whinging that label 'loop273' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 304, assignment_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "assignment_list"

    public class field_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "field_declarations"
    // G:\\downloads\\antlr\\cs.g:1332:1: field_declarations : ( ( attributes )? ( modifiers )? type field_declaration )+ ;
    public csParser.field_declarations_return field_declarations() // throws RecognitionException [1]
    {   
        csParser.field_declarations_return retval = new csParser.field_declarations_return();
        retval.Start = input.LT(1);
        int field_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.attributes_return attributes1081 = default(csParser.attributes_return);

        csParser.modifiers_return modifiers1082 = default(csParser.modifiers_return);

        csParser.type_return type1083 = default(csParser.type_return);

        csParser.field_declaration_return field_declaration1084 = default(csParser.field_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 305) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1332:19: ( ( ( attributes )? ( modifiers )? type field_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:1333:2: ( ( attributes )? ( modifiers )? type field_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1333:2: ( ( attributes )? ( modifiers )? type field_declaration )+
            	int cnt276 = 0;
            	do 
            	{
            	    int alt276 = 2;
            	    int LA276_0 = input.LA(1);

            	    if ( (LA276_0 == IDENTIFIER || (LA276_0 >= 64 && LA276_0 <= 65) || (LA276_0 >= 68 && LA276_0 <= 80) || LA276_0 == 82 || LA276_0 == 86 || (LA276_0 >= 132 && LA276_0 <= 133) || (LA276_0 >= 135 && LA276_0 <= 148) || (LA276_0 >= 150 && LA276_0 <= 152) || LA276_0 == 154 || (LA276_0 >= 157 && LA276_0 <= 168) || LA276_0 == 170 || (LA276_0 >= 177 && LA276_0 <= 178) || (LA276_0 >= 195 && LA276_0 <= 202)) )
            	    {
            	        alt276 = 1;
            	    }


            	    switch (alt276) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1333:3: ( attributes )? ( modifiers )? type field_declaration
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:1333:3: ( attributes )?
            			    	int alt274 = 2;
            			    	int LA274_0 = input.LA(1);

            			    	if ( (LA274_0 == 86) )
            			    	{
            			    	    alt274 = 1;
            			    	}
            			    	switch (alt274) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1333:3: attributes
            			    	        {
            			    	        	PushFollow(FOLLOW_attributes_in_field_declarations10293);
            			    	        	attributes1081 = attributes();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes1081.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	// G:\\downloads\\antlr\\cs.g:1333:17: ( modifiers )?
            			    	int alt275 = 2;
            			    	int LA275_0 = input.LA(1);

            			    	if ( (LA275_0 == 64 || (LA275_0 >= 68 && LA275_0 <= 80)) )
            			    	{
            			    	    alt275 = 1;
            			    	}
            			    	switch (alt275) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1333:17: modifiers
            			    	        {
            			    	        	PushFollow(FOLLOW_modifiers_in_field_declarations10298);
            			    	        	modifiers1082 = modifiers();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1082.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_type_in_field_declarations10303);
            			    	type1083 = type();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type1083.Tree);
            			    	PushFollow(FOLLOW_field_declaration_in_field_declarations10307);
            			    	field_declaration1084 = field_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, field_declaration1084.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt276 >= 1 ) goto loop276;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(276, input);
            		            throw eee;
            	    }
            	    cnt276++;
            	} while (true);

            	loop276:
            		;	// Stops C# compiler whinging that label 'loop276' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 305, field_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "field_declarations"

    public class property_declaration_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "property_declaration_list"
    // G:\\downloads\\antlr\\cs.g:1334:1: property_declaration_list : ( ( attributes )? ( modifiers )? type property_declaration )+ ;
    public csParser.property_declaration_list_return property_declaration_list() // throws RecognitionException [1]
    {   
        csParser.property_declaration_list_return retval = new csParser.property_declaration_list_return();
        retval.Start = input.LT(1);
        int property_declaration_list_StartIndex = input.Index();
        object root_0 = null;

        csParser.attributes_return attributes1085 = default(csParser.attributes_return);

        csParser.modifiers_return modifiers1086 = default(csParser.modifiers_return);

        csParser.type_return type1087 = default(csParser.type_return);

        csParser.property_declaration_return property_declaration1088 = default(csParser.property_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 306) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1334:26: ( ( ( attributes )? ( modifiers )? type property_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:1335:2: ( ( attributes )? ( modifiers )? type property_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1335:2: ( ( attributes )? ( modifiers )? type property_declaration )+
            	int cnt279 = 0;
            	do 
            	{
            	    int alt279 = 2;
            	    int LA279_0 = input.LA(1);

            	    if ( (LA279_0 == IDENTIFIER || (LA279_0 >= 64 && LA279_0 <= 65) || (LA279_0 >= 68 && LA279_0 <= 80) || LA279_0 == 82 || LA279_0 == 86 || (LA279_0 >= 132 && LA279_0 <= 133) || (LA279_0 >= 135 && LA279_0 <= 148) || (LA279_0 >= 150 && LA279_0 <= 152) || LA279_0 == 154 || (LA279_0 >= 157 && LA279_0 <= 168) || LA279_0 == 170 || (LA279_0 >= 177 && LA279_0 <= 178) || (LA279_0 >= 195 && LA279_0 <= 202)) )
            	    {
            	        alt279 = 1;
            	    }


            	    switch (alt279) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1335:3: ( attributes )? ( modifiers )? type property_declaration
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:1335:3: ( attributes )?
            			    	int alt277 = 2;
            			    	int LA277_0 = input.LA(1);

            			    	if ( (LA277_0 == 86) )
            			    	{
            			    	    alt277 = 1;
            			    	}
            			    	switch (alt277) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1335:3: attributes
            			    	        {
            			    	        	PushFollow(FOLLOW_attributes_in_property_declaration_list10318);
            			    	        	attributes1085 = attributes();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes1085.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	// G:\\downloads\\antlr\\cs.g:1335:17: ( modifiers )?
            			    	int alt278 = 2;
            			    	int LA278_0 = input.LA(1);

            			    	if ( (LA278_0 == 64 || (LA278_0 >= 68 && LA278_0 <= 80)) )
            			    	{
            			    	    alt278 = 1;
            			    	}
            			    	switch (alt278) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1335:17: modifiers
            			    	        {
            			    	        	PushFollow(FOLLOW_modifiers_in_property_declaration_list10323);
            			    	        	modifiers1086 = modifiers();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1086.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_type_in_property_declaration_list10328);
            			    	type1087 = type();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type1087.Tree);
            			    	PushFollow(FOLLOW_property_declaration_in_property_declaration_list10332);
            			    	property_declaration1088 = property_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, property_declaration1088.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt279 >= 1 ) goto loop279;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(279, input);
            		            throw eee;
            	    }
            	    cnt279++;
            	} while (true);

            	loop279:
            		;	// Stops C# compiler whinging that label 'loop279' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 306, property_declaration_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "property_declaration_list"

    public class constant_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "constant_declarations"
    // G:\\downloads\\antlr\\cs.g:1336:1: constant_declarations : ( constant_declaration )+ ;
    public csParser.constant_declarations_return constant_declarations() // throws RecognitionException [1]
    {   
        csParser.constant_declarations_return retval = new csParser.constant_declarations_return();
        retval.Start = input.LT(1);
        int constant_declarations_StartIndex = input.Index();
        object root_0 = null;

        csParser.constant_declaration_return constant_declaration1089 = default(csParser.constant_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 307) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1336:22: ( ( constant_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:1337:2: ( constant_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1337:2: ( constant_declaration )+
            	int cnt280 = 0;
            	do 
            	{
            	    int alt280 = 2;
            	    int LA280_0 = input.LA(1);

            	    if ( (LA280_0 == 81) )
            	    {
            	        alt280 = 1;
            	    }


            	    switch (alt280) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1337:2: constant_declaration
            			    {
            			    	PushFollow(FOLLOW_constant_declaration_in_constant_declarations10342);
            			    	constant_declaration1089 = constant_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, constant_declaration1089.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt280 >= 1 ) goto loop280;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(280, input);
            		            throw eee;
            	    }
            	    cnt280++;
            	} while (true);

            	loop280:
            		;	// Stops C# compiler whinging that label 'loop280' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 307, constant_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "constant_declarations"

    public class literals_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "literals"
    // G:\\downloads\\antlr\\cs.g:1338:1: literals : ( literal )+ ;
    public csParser.literals_return literals() // throws RecognitionException [1]
    {   
        csParser.literals_return retval = new csParser.literals_return();
        retval.Start = input.LT(1);
        int literals_StartIndex = input.Index();
        object root_0 = null;

        csParser.literal_return literal1090 = default(csParser.literal_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 308) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1338:9: ( ( literal )+ )
            // G:\\downloads\\antlr\\cs.g:1339:2: ( literal )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1339:2: ( literal )+
            	int cnt281 = 0;
            	do 
            	{
            	    int alt281 = 2;
            	    int LA281_0 = input.LA(1);

            	    if ( ((LA281_0 >= Real_literal && LA281_0 <= NULL)) )
            	    {
            	        alt281 = 1;
            	    }


            	    switch (alt281) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1339:2: literal
            			    {
            			    	PushFollow(FOLLOW_literal_in_literals10350);
            			    	literal1090 = literal();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, literal1090.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt281 >= 1 ) goto loop281;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(281, input);
            		            throw eee;
            	    }
            	    cnt281++;
            	} while (true);

            	loop281:
            		;	// Stops C# compiler whinging that label 'loop281' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 308, literals_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "literals"

    public class delegate_declaration_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "delegate_declaration_list"
    // G:\\downloads\\antlr\\cs.g:1340:1: delegate_declaration_list : ( ( attributes )? ( modifiers )? delegate_declaration )+ ;
    public csParser.delegate_declaration_list_return delegate_declaration_list() // throws RecognitionException [1]
    {   
        csParser.delegate_declaration_list_return retval = new csParser.delegate_declaration_list_return();
        retval.Start = input.LT(1);
        int delegate_declaration_list_StartIndex = input.Index();
        object root_0 = null;

        csParser.attributes_return attributes1091 = default(csParser.attributes_return);

        csParser.modifiers_return modifiers1092 = default(csParser.modifiers_return);

        csParser.delegate_declaration_return delegate_declaration1093 = default(csParser.delegate_declaration_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 309) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1340:26: ( ( ( attributes )? ( modifiers )? delegate_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:1341:2: ( ( attributes )? ( modifiers )? delegate_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1341:2: ( ( attributes )? ( modifiers )? delegate_declaration )+
            	int cnt284 = 0;
            	do 
            	{
            	    int alt284 = 2;
            	    int LA284_0 = input.LA(1);

            	    if ( (LA284_0 == 64 || (LA284_0 >= 68 && LA284_0 <= 80) || LA284_0 == 86 || LA284_0 == 97) )
            	    {
            	        alt284 = 1;
            	    }


            	    switch (alt284) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1341:3: ( attributes )? ( modifiers )? delegate_declaration
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:1341:3: ( attributes )?
            			    	int alt282 = 2;
            			    	int LA282_0 = input.LA(1);

            			    	if ( (LA282_0 == 86) )
            			    	{
            			    	    alt282 = 1;
            			    	}
            			    	switch (alt282) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1341:3: attributes
            			    	        {
            			    	        	PushFollow(FOLLOW_attributes_in_delegate_declaration_list10360);
            			    	        	attributes1091 = attributes();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, attributes1091.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	// G:\\downloads\\antlr\\cs.g:1341:17: ( modifiers )?
            			    	int alt283 = 2;
            			    	int LA283_0 = input.LA(1);

            			    	if ( (LA283_0 == 64 || (LA283_0 >= 68 && LA283_0 <= 80)) )
            			    	{
            			    	    alt283 = 1;
            			    	}
            			    	switch (alt283) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1341:17: modifiers
            			    	        {
            			    	        	PushFollow(FOLLOW_modifiers_in_delegate_declaration_list10365);
            			    	        	modifiers1092 = modifiers();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1092.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_delegate_declaration_in_delegate_declaration_list10370);
            			    	delegate_declaration1093 = delegate_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, delegate_declaration1093.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt284 >= 1 ) goto loop284;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(284, input);
            		            throw eee;
            	    }
            	    cnt284++;
            	} while (true);

            	loop284:
            		;	// Stops C# compiler whinging that label 'loop284' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 309, delegate_declaration_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "delegate_declaration_list"

    public class local_variable_declaration_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_variable_declaration_list"
    // G:\\downloads\\antlr\\cs.g:1342:1: local_variable_declaration_list : ( local_variable_declaration ';' )+ ;
    public csParser.local_variable_declaration_list_return local_variable_declaration_list() // throws RecognitionException [1]
    {   
        csParser.local_variable_declaration_list_return retval = new csParser.local_variable_declaration_list_return();
        retval.Start = input.LT(1);
        int local_variable_declaration_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1095 = null;
        csParser.local_variable_declaration_return local_variable_declaration1094 = default(csParser.local_variable_declaration_return);


        object char_literal1095_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 310) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1342:32: ( ( local_variable_declaration ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1343:2: ( local_variable_declaration ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1343:2: ( local_variable_declaration ';' )+
            	int cnt285 = 0;
            	do 
            	{
            	    int alt285 = 2;
            	    int LA285_0 = input.LA(1);

            	    if ( (LA285_0 == IDENTIFIER || LA285_0 == 65 || LA285_0 == 82 || (LA285_0 >= 132 && LA285_0 <= 133) || (LA285_0 >= 135 && LA285_0 <= 148) || (LA285_0 >= 150 && LA285_0 <= 152) || LA285_0 == 154 || (LA285_0 >= 157 && LA285_0 <= 168) || LA285_0 == 170 || (LA285_0 >= 177 && LA285_0 <= 178) || (LA285_0 >= 195 && LA285_0 <= 202)) )
            	    {
            	        alt285 = 1;
            	    }


            	    switch (alt285) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1343:3: local_variable_declaration ';'
            			    {
            			    	PushFollow(FOLLOW_local_variable_declaration_in_local_variable_declaration_list10381);
            			    	local_variable_declaration1094 = local_variable_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_declaration1094.Tree);
            			    	char_literal1095=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_local_variable_declaration_list10383); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1095_tree = (object)adaptor.Create(char_literal1095);
            			    		adaptor.AddChild(root_0, char_literal1095_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt285 >= 1 ) goto loop285;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(285, input);
            		            throw eee;
            	    }
            	    cnt285++;
            	} while (true);

            	loop285:
            		;	// Stops C# compiler whinging that label 'loop285' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 310, local_variable_declaration_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_variable_declaration_list"

    public class local_variable_initializer_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "local_variable_initializer_list"
    // G:\\downloads\\antlr\\cs.g:1344:1: local_variable_initializer_list : ( local_variable_initializer ';' )+ ;
    public csParser.local_variable_initializer_list_return local_variable_initializer_list() // throws RecognitionException [1]
    {   
        csParser.local_variable_initializer_list_return retval = new csParser.local_variable_initializer_list_return();
        retval.Start = input.LT(1);
        int local_variable_initializer_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1097 = null;
        csParser.local_variable_initializer_return local_variable_initializer1096 = default(csParser.local_variable_initializer_return);


        object char_literal1097_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 311) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1344:32: ( ( local_variable_initializer ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1345:2: ( local_variable_initializer ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1345:2: ( local_variable_initializer ';' )+
            	int cnt286 = 0;
            	do 
            	{
            	    int alt286 = 2;
            	    int LA286_0 = input.LA(1);

            	    if ( ((LA286_0 >= IDENTIFIER && LA286_0 <= NULL) || LA286_0 == MINUS || LA286_0 == 62 || LA286_0 == 65 || LA286_0 == 68 || LA286_0 == 83 || LA286_0 == 85 || LA286_0 == 88 || (LA286_0 >= 93 && LA286_0 <= 98) || LA286_0 == 100 || (LA286_0 >= 102 && LA286_0 <= 106) || LA286_0 == 117 || (LA286_0 >= 132 && LA286_0 <= 133) || (LA286_0 >= 135 && LA286_0 <= 148) || (LA286_0 >= 150 && LA286_0 <= 152) || LA286_0 == 154 || (LA286_0 >= 157 && LA286_0 <= 168) || LA286_0 == 170 || (LA286_0 >= 177 && LA286_0 <= 179) || (LA286_0 >= 195 && LA286_0 <= 202)) )
            	    {
            	        alt286 = 1;
            	    }


            	    switch (alt286) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1345:3: local_variable_initializer ';'
            			    {
            			    	PushFollow(FOLLOW_local_variable_initializer_in_local_variable_initializer_list10394);
            			    	local_variable_initializer1096 = local_variable_initializer();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, local_variable_initializer1096.Tree);
            			    	char_literal1097=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_local_variable_initializer_list10396); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1097_tree = (object)adaptor.Create(char_literal1097);
            			    		adaptor.AddChild(root_0, char_literal1097_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt286 >= 1 ) goto loop286;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(286, input);
            		            throw eee;
            	    }
            	    cnt286++;
            	} while (true);

            	loop286:
            		;	// Stops C# compiler whinging that label 'loop286' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 311, local_variable_initializer_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "local_variable_initializer_list"

    public class expression_list_test_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "expression_list_test"
    // G:\\downloads\\antlr\\cs.g:1346:1: expression_list_test : ( expression ';' )+ ;
    public csParser.expression_list_test_return expression_list_test() // throws RecognitionException [1]
    {   
        csParser.expression_list_test_return retval = new csParser.expression_list_test_return();
        retval.Start = input.LT(1);
        int expression_list_test_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1099 = null;
        csParser.expression_return expression1098 = default(csParser.expression_return);


        object char_literal1099_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 312) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1346:21: ( ( expression ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1347:2: ( expression ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1347:2: ( expression ';' )+
            	int cnt287 = 0;
            	do 
            	{
            	    int alt287 = 2;
            	    int LA287_0 = input.LA(1);

            	    if ( ((LA287_0 >= IDENTIFIER && LA287_0 <= NULL) || LA287_0 == MINUS || LA287_0 == 65 || LA287_0 == 68 || LA287_0 == 83 || LA287_0 == 85 || LA287_0 == 88 || (LA287_0 >= 93 && LA287_0 <= 98) || LA287_0 == 100 || (LA287_0 >= 102 && LA287_0 <= 106) || LA287_0 == 117 || (LA287_0 >= 132 && LA287_0 <= 133) || (LA287_0 >= 135 && LA287_0 <= 148) || (LA287_0 >= 150 && LA287_0 <= 152) || LA287_0 == 154 || (LA287_0 >= 157 && LA287_0 <= 168) || LA287_0 == 170 || (LA287_0 >= 177 && LA287_0 <= 178) || (LA287_0 >= 195 && LA287_0 <= 202)) )
            	    {
            	        alt287 = 1;
            	    }


            	    switch (alt287) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1347:3: expression ';'
            			    {
            			    	PushFollow(FOLLOW_expression_in_expression_list_test10407);
            			    	expression1098 = expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expression1098.Tree);
            			    	char_literal1099=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_expression_list_test10409); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1099_tree = (object)adaptor.Create(char_literal1099);
            			    		adaptor.AddChild(root_0, char_literal1099_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt287 >= 1 ) goto loop287;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(287, input);
            		            throw eee;
            	    }
            	    cnt287++;
            	} while (true);

            	loop287:
            		;	// Stops C# compiler whinging that label 'loop287' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 312, expression_list_test_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expression_list_test"

    public class unary_expression_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unary_expression_list"
    // G:\\downloads\\antlr\\cs.g:1348:1: unary_expression_list : ( unary_expression ';' )+ ;
    public csParser.unary_expression_list_return unary_expression_list() // throws RecognitionException [1]
    {   
        csParser.unary_expression_list_return retval = new csParser.unary_expression_list_return();
        retval.Start = input.LT(1);
        int unary_expression_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1101 = null;
        csParser.unary_expression_return unary_expression1100 = default(csParser.unary_expression_return);


        object char_literal1101_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 313) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1348:22: ( ( unary_expression ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1349:2: ( unary_expression ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1349:2: ( unary_expression ';' )+
            	int cnt288 = 0;
            	do 
            	{
            	    int alt288 = 2;
            	    int LA288_0 = input.LA(1);

            	    if ( ((LA288_0 >= IDENTIFIER && LA288_0 <= NULL) || LA288_0 == MINUS || LA288_0 == 65 || LA288_0 == 68 || LA288_0 == 83 || LA288_0 == 85 || LA288_0 == 88 || (LA288_0 >= 93 && LA288_0 <= 98) || LA288_0 == 100 || (LA288_0 >= 102 && LA288_0 <= 106) || LA288_0 == 117 || (LA288_0 >= 132 && LA288_0 <= 133) || (LA288_0 >= 135 && LA288_0 <= 148) || (LA288_0 >= 150 && LA288_0 <= 152) || LA288_0 == 154 || (LA288_0 >= 157 && LA288_0 <= 168) || LA288_0 == 170 || (LA288_0 >= 177 && LA288_0 <= 178) || (LA288_0 >= 195 && LA288_0 <= 202)) )
            	    {
            	        alt288 = 1;
            	    }


            	    switch (alt288) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1349:3: unary_expression ';'
            			    {
            			    	PushFollow(FOLLOW_unary_expression_in_unary_expression_list10420);
            			    	unary_expression1100 = unary_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unary_expression1100.Tree);
            			    	char_literal1101=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_unary_expression_list10422); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1101_tree = (object)adaptor.Create(char_literal1101);
            			    		adaptor.AddChild(root_0, char_literal1101_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt288 >= 1 ) goto loop288;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(288, input);
            		            throw eee;
            	    }
            	    cnt288++;
            	} while (true);

            	loop288:
            		;	// Stops C# compiler whinging that label 'loop288' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 313, unary_expression_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unary_expression_list"

    public class invocation_expression_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "invocation_expression_list"
    // G:\\downloads\\antlr\\cs.g:1350:1: invocation_expression_list : ( invocation_expression ';' )+ ;
    public csParser.invocation_expression_list_return invocation_expression_list() // throws RecognitionException [1]
    {   
        csParser.invocation_expression_list_return retval = new csParser.invocation_expression_list_return();
        retval.Start = input.LT(1);
        int invocation_expression_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1103 = null;
        csParser.invocation_expression_return invocation_expression1102 = default(csParser.invocation_expression_return);


        object char_literal1103_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 314) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1350:27: ( ( invocation_expression ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1351:2: ( invocation_expression ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1351:2: ( invocation_expression ';' )+
            	int cnt289 = 0;
            	do 
            	{
            	    int alt289 = 2;
            	    int LA289_0 = input.LA(1);

            	    if ( (LA289_0 == IDENTIFIER || LA289_0 == 65 || LA289_0 == 83 || LA289_0 == 85 || LA289_0 == 98 || (LA289_0 >= 132 && LA289_0 <= 133) || (LA289_0 >= 135 && LA289_0 <= 148) || (LA289_0 >= 150 && LA289_0 <= 152) || LA289_0 == 154 || (LA289_0 >= 157 && LA289_0 <= 168) || LA289_0 == 170 || (LA289_0 >= 177 && LA289_0 <= 178) || (LA289_0 >= 195 && LA289_0 <= 202)) )
            	    {
            	        alt289 = 1;
            	    }


            	    switch (alt289) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1351:3: invocation_expression ';'
            			    {
            			    	PushFollow(FOLLOW_invocation_expression_in_invocation_expression_list10433);
            			    	invocation_expression1102 = invocation_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, invocation_expression1102.Tree);
            			    	char_literal1103=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_invocation_expression_list10435); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1103_tree = (object)adaptor.Create(char_literal1103);
            			    		adaptor.AddChild(root_0, char_literal1103_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt289 >= 1 ) goto loop289;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(289, input);
            		            throw eee;
            	    }
            	    cnt289++;
            	} while (true);

            	loop289:
            		;	// Stops C# compiler whinging that label 'loop289' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 314, invocation_expression_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "invocation_expression_list"

    public class primary_expression_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "primary_expression_list"
    // G:\\downloads\\antlr\\cs.g:1352:1: primary_expression_list : ( primary_expression ';' )+ ;
    public csParser.primary_expression_list_return primary_expression_list() // throws RecognitionException [1]
    {   
        csParser.primary_expression_list_return retval = new csParser.primary_expression_list_return();
        retval.Start = input.LT(1);
        int primary_expression_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1105 = null;
        csParser.primary_expression_return primary_expression1104 = default(csParser.primary_expression_return);


        object char_literal1105_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 315) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1352:24: ( ( primary_expression ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1353:2: ( primary_expression ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1353:2: ( primary_expression ';' )+
            	int cnt290 = 0;
            	do 
            	{
            	    int alt290 = 2;
            	    int LA290_0 = input.LA(1);

            	    if ( ((LA290_0 >= IDENTIFIER && LA290_0 <= NULL) || LA290_0 == 65 || LA290_0 == 68 || LA290_0 == 83 || LA290_0 == 85 || LA290_0 == 88 || (LA290_0 >= 93 && LA290_0 <= 98) || (LA290_0 >= 132 && LA290_0 <= 133) || (LA290_0 >= 135 && LA290_0 <= 148) || (LA290_0 >= 150 && LA290_0 <= 152) || LA290_0 == 154 || (LA290_0 >= 157 && LA290_0 <= 168) || LA290_0 == 170 || (LA290_0 >= 177 && LA290_0 <= 178) || (LA290_0 >= 195 && LA290_0 <= 202)) )
            	    {
            	        alt290 = 1;
            	    }


            	    switch (alt290) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1353:3: primary_expression ';'
            			    {
            			    	PushFollow(FOLLOW_primary_expression_in_primary_expression_list10446);
            			    	primary_expression1104 = primary_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primary_expression1104.Tree);
            			    	char_literal1105=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_primary_expression_list10448); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1105_tree = (object)adaptor.Create(char_literal1105);
            			    		adaptor.AddChild(root_0, char_literal1105_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt290 >= 1 ) goto loop290;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(290, input);
            		            throw eee;
            	    }
            	    cnt290++;
            	} while (true);

            	loop290:
            		;	// Stops C# compiler whinging that label 'loop290' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 315, primary_expression_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primary_expression_list"

    public class non_assignment_expression_list_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "non_assignment_expression_list"
    // G:\\downloads\\antlr\\cs.g:1354:1: non_assignment_expression_list : ( non_assignment_expression ';' )+ ;
    public csParser.non_assignment_expression_list_return non_assignment_expression_list() // throws RecognitionException [1]
    {   
        csParser.non_assignment_expression_list_return retval = new csParser.non_assignment_expression_list_return();
        retval.Start = input.LT(1);
        int non_assignment_expression_list_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal1107 = null;
        csParser.non_assignment_expression_return non_assignment_expression1106 = default(csParser.non_assignment_expression_return);


        object char_literal1107_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 316) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1354:31: ( ( non_assignment_expression ';' )+ )
            // G:\\downloads\\antlr\\cs.g:1355:2: ( non_assignment_expression ';' )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1355:2: ( non_assignment_expression ';' )+
            	int cnt291 = 0;
            	do 
            	{
            	    int alt291 = 2;
            	    int LA291_0 = input.LA(1);

            	    if ( ((LA291_0 >= IDENTIFIER && LA291_0 <= NULL) || LA291_0 == MINUS || LA291_0 == 65 || LA291_0 == 68 || LA291_0 == 83 || LA291_0 == 85 || LA291_0 == 88 || (LA291_0 >= 93 && LA291_0 <= 98) || LA291_0 == 100 || (LA291_0 >= 102 && LA291_0 <= 106) || LA291_0 == 117 || (LA291_0 >= 132 && LA291_0 <= 133) || (LA291_0 >= 135 && LA291_0 <= 148) || (LA291_0 >= 150 && LA291_0 <= 152) || LA291_0 == 154 || (LA291_0 >= 157 && LA291_0 <= 168) || LA291_0 == 170 || (LA291_0 >= 177 && LA291_0 <= 178) || (LA291_0 >= 195 && LA291_0 <= 202)) )
            	    {
            	        alt291 = 1;
            	    }


            	    switch (alt291) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1355:3: non_assignment_expression ';'
            			    {
            			    	PushFollow(FOLLOW_non_assignment_expression_in_non_assignment_expression_list10459);
            			    	non_assignment_expression1106 = non_assignment_expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, non_assignment_expression1106.Tree);
            			    	char_literal1107=(IToken)Match(input,SEMI,FOLLOW_SEMI_in_non_assignment_expression_list10461); if (state.failed) return retval;
            			    	if ( state.backtracking == 0 )
            			    	{char_literal1107_tree = (object)adaptor.Create(char_literal1107);
            			    		adaptor.AddChild(root_0, char_literal1107_tree);
            			    	}

            			    }
            			    break;

            			default:
            			    if ( cnt291 >= 1 ) goto loop291;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(291, input);
            		            throw eee;
            	    }
            	    cnt291++;
            	} while (true);

            	loop291:
            		;	// Stops C# compiler whinging that label 'loop291' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 316, non_assignment_expression_list_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "non_assignment_expression_list"

    public class method_declarations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "method_declarations"
    // G:\\downloads\\antlr\\cs.g:1356:1: method_declarations : ( ( modifiers )? ( 'void' | type ) method_declaration )+ ;
    public csParser.method_declarations_return method_declarations() // throws RecognitionException [1]
    {   
        csParser.method_declarations_return retval = new csParser.method_declarations_return();
        retval.Start = input.LT(1);
        int method_declarations_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1109 = null;
        csParser.modifiers_return modifiers1108 = default(csParser.modifiers_return);

        csParser.type_return type1110 = default(csParser.type_return);

        csParser.method_declaration_return method_declaration1111 = default(csParser.method_declaration_return);


        object string_literal1109_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 317) ) 
    	    {
    	    	return retval; 
    	    }
            // G:\\downloads\\antlr\\cs.g:1356:20: ( ( ( modifiers )? ( 'void' | type ) method_declaration )+ )
            // G:\\downloads\\antlr\\cs.g:1357:2: ( ( modifiers )? ( 'void' | type ) method_declaration )+
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// G:\\downloads\\antlr\\cs.g:1357:2: ( ( modifiers )? ( 'void' | type ) method_declaration )+
            	int cnt294 = 0;
            	do 
            	{
            	    int alt294 = 2;
            	    int LA294_0 = input.LA(1);

            	    if ( (LA294_0 == IDENTIFIER || (LA294_0 >= 64 && LA294_0 <= 65) || (LA294_0 >= 68 && LA294_0 <= 80) || LA294_0 == 82 || (LA294_0 >= 132 && LA294_0 <= 133) || (LA294_0 >= 135 && LA294_0 <= 148) || (LA294_0 >= 150 && LA294_0 <= 152) || LA294_0 == 154 || (LA294_0 >= 157 && LA294_0 <= 168) || LA294_0 == 170 || (LA294_0 >= 177 && LA294_0 <= 178) || (LA294_0 >= 195 && LA294_0 <= 202)) )
            	    {
            	        alt294 = 1;
            	    }


            	    switch (alt294) 
            		{
            			case 1 :
            			    // G:\\downloads\\antlr\\cs.g:1357:3: ( modifiers )? ( 'void' | type ) method_declaration
            			    {
            			    	// G:\\downloads\\antlr\\cs.g:1357:3: ( modifiers )?
            			    	int alt292 = 2;
            			    	int LA292_0 = input.LA(1);

            			    	if ( (LA292_0 == 64 || (LA292_0 >= 68 && LA292_0 <= 80)) )
            			    	{
            			    	    alt292 = 1;
            			    	}
            			    	switch (alt292) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1357:3: modifiers
            			    	        {
            			    	        	PushFollow(FOLLOW_modifiers_in_method_declarations10472);
            			    	        	modifiers1108 = modifiers();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, modifiers1108.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	// G:\\downloads\\antlr\\cs.g:1357:14: ( 'void' | type )
            			    	int alt293 = 2;
            			    	int LA293_0 = input.LA(1);

            			    	if ( (LA293_0 == 82) )
            			    	{
            			    	    int LA293_1 = input.LA(2);

            			    	    if ( (LA293_1 == 100) )
            			    	    {
            			    	        alt293 = 2;
            			    	    }
            			    	    else if ( ((LA293_1 >= IDENTIFIER && LA293_1 <= NULL) || LA293_1 == 65 || (LA293_1 >= 132 && LA293_1 <= 133) || (LA293_1 >= 135 && LA293_1 <= 148) || (LA293_1 >= 150 && LA293_1 <= 152) || LA293_1 == 154 || (LA293_1 >= 157 && LA293_1 <= 168) || LA293_1 == 170 || (LA293_1 >= 177 && LA293_1 <= 178) || (LA293_1 >= 195 && LA293_1 <= 202)) )
            			    	    {
            			    	        alt293 = 1;
            			    	    }
            			    	    else 
            			    	    {
            			    	        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	        NoViableAltException nvae_d293s1 =
            			    	            new NoViableAltException("", 293, 1, input);

            			    	        throw nvae_d293s1;
            			    	    }
            			    	}
            			    	else if ( (LA293_0 == IDENTIFIER || LA293_0 == 65 || (LA293_0 >= 132 && LA293_0 <= 133) || (LA293_0 >= 135 && LA293_0 <= 148) || (LA293_0 >= 150 && LA293_0 <= 152) || LA293_0 == 154 || (LA293_0 >= 157 && LA293_0 <= 168) || LA293_0 == 170 || (LA293_0 >= 177 && LA293_0 <= 178) || (LA293_0 >= 195 && LA293_0 <= 202)) )
            			    	{
            			    	    alt293 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            			    	    NoViableAltException nvae_d293s0 =
            			    	        new NoViableAltException("", 293, 0, input);

            			    	    throw nvae_d293s0;
            			    	}
            			    	switch (alt293) 
            			    	{
            			    	    case 1 :
            			    	        // G:\\downloads\\antlr\\cs.g:1357:15: 'void'
            			    	        {
            			    	        	string_literal1109=(IToken)Match(input,82,FOLLOW_82_in_method_declarations10476); if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 )
            			    	        	{string_literal1109_tree = (object)adaptor.Create(string_literal1109);
            			    	        		adaptor.AddChild(root_0, string_literal1109_tree);
            			    	        	}

            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // G:\\downloads\\antlr\\cs.g:1357:24: type
            			    	        {
            			    	        	PushFollow(FOLLOW_type_in_method_declarations10480);
            			    	        	type1110 = type();
            			    	        	state.followingStackPointer--;
            			    	        	if (state.failed) return retval;
            			    	        	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, type1110.Tree);

            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_method_declaration_in_method_declarations10483);
            			    	method_declaration1111 = method_declaration();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, method_declaration1111.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt294 >= 1 ) goto loop294;
            			    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            		            EarlyExitException eee =
            		                new EarlyExitException(294, input);
            		            throw eee;
            	    }
            	    cnt294++;
            	} while (true);

            	loop294:
            		;	// Stops C# compiler whinging that label 'loop294' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( state.backtracking==0 )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 317, method_declarations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "method_declarations"

    // $ANTLR start "synpred1_cs"
    public void synpred1_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:68:2: ( 'partial' )
        // G:\\downloads\\antlr\\cs.g:68:3: 'partial'
        {
        	Match(input,67,FOLLOW_67_in_synpred1_cs285); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred1_cs"

    // $ANTLR start "synpred2_cs"
    public void synpred2_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:99:11: ( member_name '(' )
        // G:\\downloads\\antlr\\cs.g:99:12: member_name '('
        {
        	PushFollow(FOLLOW_member_name_in_synpred2_cs549);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,88,FOLLOW_88_in_synpred2_cs553); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred2_cs"

    // $ANTLR start "synpred3_cs"
    public void synpred3_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:100:8: ( member_name '{' )
        // G:\\downloads\\antlr\\cs.g:100:9: member_name '{'
        {
        	PushFollow(FOLLOW_member_name_in_synpred3_cs568);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,62,FOLLOW_62_in_synpred3_cs572); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred3_cs"

    // $ANTLR start "synpred4_cs"
    public void synpred4_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:101:8: ( member_name '.' 'this' )
        // G:\\downloads\\antlr\\cs.g:101:9: member_name '.' 'this'
        {
        	PushFollow(FOLLOW_member_name_in_synpred4_cs587);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,DOT,FOLLOW_DOT_in_synpred4_cs591); if (state.failed) return ;
        	Match(input,83,FOLLOW_83_in_synpred4_cs595); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred4_cs"

    // $ANTLR start "synpred5_cs"
    public void synpred5_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:119:2: ( 'this' brackets )
        // G:\\downloads\\antlr\\cs.g:119:3: 'this' brackets
        {
        	Match(input,83,FOLLOW_83_in_synpred5_cs715); if (state.failed) return ;
        	PushFollow(FOLLOW_brackets_in_synpred5_cs720);
        	brackets();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred5_cs"

    // $ANTLR start "synpred6_cs"
    public void synpred6_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:120:4: ( 'base' brackets )
        // G:\\downloads\\antlr\\cs.g:120:5: 'base' brackets
        {
        	Match(input,85,FOLLOW_85_in_synpred6_cs740); if (state.failed) return ;
        	PushFollow(FOLLOW_brackets_in_synpred6_cs744);
        	brackets();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred6_cs"

    // $ANTLR start "synpred7_cs"
    public void synpred7_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:122:14: ( object_creation_expression ( '.' | '->' | '[' ) )
        // G:\\downloads\\antlr\\cs.g:122:15: object_creation_expression ( '.' | '->' | '[' )
        {
        	PushFollow(FOLLOW_object_creation_expression_in_synpred7_cs780);
        	object_creation_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	if ( (input.LA(1) >= DOT && input.LA(1) <= PTR) || input.LA(1) == 86 ) 
        	{
        	    input.Consume();
        	    state.errorRecovery = false;state.failed = false;
        	}
        	else 
        	{
        	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
        	    MismatchedSetException mse = new MismatchedSetException(null,input);
        	    throw mse;
        	}


        }
    }
    // $ANTLR end "synpred7_cs"

    // $ANTLR start "synpred8_cs"
    public void synpred8_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:126:7: ( delegate_creation_expression )
        // G:\\downloads\\antlr\\cs.g:126:8: delegate_creation_expression
        {
        	PushFollow(FOLLOW_delegate_creation_expression_in_synpred8_cs828);
        	delegate_creation_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred8_cs"

    // $ANTLR start "synpred9_cs"
    public void synpred9_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:138:4: ( identifier '<' )
        // G:\\downloads\\antlr\\cs.g:138:5: identifier '<'
        {
        	PushFollow(FOLLOW_identifier_in_synpred9_cs953);
        	identifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,99,FOLLOW_99_in_synpred9_cs958); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred9_cs"

    // $ANTLR start "synpred10_cs"
    public void synpred10_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:176:4: ( '(' type ')' )
        // G:\\downloads\\antlr\\cs.g:176:5: '(' type ')'
        {
        	Match(input,88,FOLLOW_88_in_synpred10_cs1210); if (state.failed) return ;
        	PushFollow(FOLLOW_type_in_synpred10_cs1214);
        	type();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,RPAREN,FOLLOW_RPAREN_in_synpred10_cs1218); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred10_cs"

    // $ANTLR start "synpred11_cs"
    public void synpred11_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:204:2: ( array_creation_expression )
        // G:\\downloads\\antlr\\cs.g:204:3: array_creation_expression
        {
        	PushFollow(FOLLOW_array_creation_expression_in_synpred11_cs1460);
        	array_creation_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred11_cs"

    // $ANTLR start "synpred12_cs"
    public void synpred12_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:213:11: ( arguments ( '[' | '.' | '->' ) )
        // G:\\downloads\\antlr\\cs.g:213:12: arguments ( '[' | '.' | '->' )
        {
        	PushFollow(FOLLOW_arguments_in_synpred12_cs1540);
        	arguments();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	if ( (input.LA(1) >= DOT && input.LA(1) <= PTR) || input.LA(1) == 86 ) 
        	{
        	    input.Consume();
        	    state.errorRecovery = false;state.failed = false;
        	}
        	else 
        	{
        	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
        	    MismatchedSetException mse = new MismatchedSetException(null,input);
        	    throw mse;
        	}


        }
    }
    // $ANTLR end "synpred12_cs"

    // $ANTLR start "synpred13_cs"
    public void synpred13_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:284:20: ( unbound_type_name )
        // G:\\downloads\\antlr\\cs.g:284:21: unbound_type_name
        {
        	PushFollow(FOLLOW_unbound_type_name_in_synpred13_cs2070);
        	unbound_type_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred13_cs"

    // $ANTLR start "synpred14_cs"
    public void synpred14_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:294:5: ( generic_dimension_specifier '.' )
        // G:\\downloads\\antlr\\cs.g:294:6: generic_dimension_specifier '.'
        {
        	PushFollow(FOLLOW_generic_dimension_specifier_in_synpred14_cs2128);
        	generic_dimension_specifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,DOT,FOLLOW_DOT_in_synpred14_cs2132); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred14_cs"

    // $ANTLR start "synpred15_cs"
    public void synpred15_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:317:2: ( identifier '<' )
        // G:\\downloads\\antlr\\cs.g:317:3: identifier '<'
        {
        	PushFollow(FOLLOW_identifier_in_synpred15_cs2264);
        	identifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,99,FOLLOW_99_in_synpred15_cs2268); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred15_cs"

    // $ANTLR start "synpred16_cs"
    public void synpred16_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:325:4: ( identifier '<' )
        // G:\\downloads\\antlr\\cs.g:325:5: identifier '<'
        {
        	PushFollow(FOLLOW_identifier_in_synpred16_cs2313);
        	identifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,99,FOLLOW_99_in_synpred16_cs2318); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred16_cs"

    // $ANTLR start "synpred17_cs"
    public void synpred17_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:342:4: ( ( predefined_type | type_name ) rank_specifiers )
        // G:\\downloads\\antlr\\cs.g:342:5: ( predefined_type | type_name ) rank_specifiers
        {
        	// G:\\downloads\\antlr\\cs.g:342:5: ( predefined_type | type_name )
        	int alt295 = 2;
        	int LA295_0 = input.LA(1);

        	if ( ((LA295_0 >= 160 && LA295_0 <= 168) || (LA295_0 >= 196 && LA295_0 <= 201)) )
        	{
        	    alt295 = 1;
        	}
        	else if ( (LA295_0 == IDENTIFIER || LA295_0 == 65 || (LA295_0 >= 132 && LA295_0 <= 133) || (LA295_0 >= 135 && LA295_0 <= 148) || (LA295_0 >= 150 && LA295_0 <= 152) || LA295_0 == 154 || (LA295_0 >= 157 && LA295_0 <= 159) || LA295_0 == 170 || (LA295_0 >= 177 && LA295_0 <= 178) || LA295_0 == 195 || LA295_0 == 202) )
        	{
        	    alt295 = 2;
        	}
        	else 
        	{
        	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
        	    NoViableAltException nvae_d295s0 =
        	        new NoViableAltException("", 295, 0, input);

        	    throw nvae_d295s0;
        	}
        	switch (alt295) 
        	{
        	    case 1 :
        	        // G:\\downloads\\antlr\\cs.g:342:6: predefined_type
        	        {
        	        	PushFollow(FOLLOW_predefined_type_in_synpred17_cs2411);
        	        	predefined_type();
        	        	state.followingStackPointer--;
        	        	if (state.failed) return ;

        	        }
        	        break;
        	    case 2 :
        	        // G:\\downloads\\antlr\\cs.g:342:24: type_name
        	        {
        	        	PushFollow(FOLLOW_type_name_in_synpred17_cs2415);
        	        	type_name();
        	        	state.followingStackPointer--;
        	        	if (state.failed) return ;

        	        }
        	        break;

        	}

        	PushFollow(FOLLOW_rank_specifiers_in_synpred17_cs2419);
        	rank_specifiers();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred17_cs"

    // $ANTLR start "synpred18_cs"
    public void synpred18_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:343:4: ( ( predefined_type | type_name ) ( ( '*' )+ | '?' ) )
        // G:\\downloads\\antlr\\cs.g:343:5: ( predefined_type | type_name ) ( ( '*' )+ | '?' )
        {
        	// G:\\downloads\\antlr\\cs.g:343:5: ( predefined_type | type_name )
        	int alt296 = 2;
        	int LA296_0 = input.LA(1);

        	if ( ((LA296_0 >= 160 && LA296_0 <= 168) || (LA296_0 >= 196 && LA296_0 <= 201)) )
        	{
        	    alt296 = 1;
        	}
        	else if ( (LA296_0 == IDENTIFIER || LA296_0 == 65 || (LA296_0 >= 132 && LA296_0 <= 133) || (LA296_0 >= 135 && LA296_0 <= 148) || (LA296_0 >= 150 && LA296_0 <= 152) || LA296_0 == 154 || (LA296_0 >= 157 && LA296_0 <= 159) || LA296_0 == 170 || (LA296_0 >= 177 && LA296_0 <= 178) || LA296_0 == 195 || LA296_0 == 202) )
        	{
        	    alt296 = 2;
        	}
        	else 
        	{
        	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
        	    NoViableAltException nvae_d296s0 =
        	        new NoViableAltException("", 296, 0, input);

        	    throw nvae_d296s0;
        	}
        	switch (alt296) 
        	{
        	    case 1 :
        	        // G:\\downloads\\antlr\\cs.g:343:6: predefined_type
        	        {
        	        	PushFollow(FOLLOW_predefined_type_in_synpred18_cs2446);
        	        	predefined_type();
        	        	state.followingStackPointer--;
        	        	if (state.failed) return ;

        	        }
        	        break;
        	    case 2 :
        	        // G:\\downloads\\antlr\\cs.g:343:24: type_name
        	        {
        	        	PushFollow(FOLLOW_type_name_in_synpred18_cs2450);
        	        	type_name();
        	        	state.followingStackPointer--;
        	        	if (state.failed) return ;

        	        }
        	        break;

        	}

        	// G:\\downloads\\antlr\\cs.g:343:36: ( ( '*' )+ | '?' )
        	int alt298 = 2;
        	int LA298_0 = input.LA(1);

        	if ( (LA298_0 == 100) )
        	{
        	    alt298 = 1;
        	}
        	else if ( (LA298_0 == 101) )
        	{
        	    alt298 = 2;
        	}
        	else 
        	{
        	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
        	    NoViableAltException nvae_d298s0 =
        	        new NoViableAltException("", 298, 0, input);

        	    throw nvae_d298s0;
        	}
        	switch (alt298) 
        	{
        	    case 1 :
        	        // G:\\downloads\\antlr\\cs.g:343:37: ( '*' )+
        	        {
        	        	// G:\\downloads\\antlr\\cs.g:343:37: ( '*' )+
        	        	int cnt297 = 0;
        	        	do 
        	        	{
        	        	    int alt297 = 2;
        	        	    int LA297_0 = input.LA(1);

        	        	    if ( (LA297_0 == 100) )
        	        	    {
        	        	        alt297 = 1;
        	        	    }


        	        	    switch (alt297) 
        	        		{
        	        			case 1 :
        	        			    // G:\\downloads\\antlr\\cs.g:343:37: '*'
        	        			    {
        	        			    	Match(input,100,FOLLOW_100_in_synpred18_cs2455); if (state.failed) return ;

        	        			    }
        	        			    break;

        	        			default:
        	        			    if ( cnt297 >= 1 ) goto loop297;
        	        			    if ( state.backtracking > 0 ) {state.failed = true; return ;}
        	        		            EarlyExitException eee =
        	        		                new EarlyExitException(297, input);
        	        		            throw eee;
        	        	    }
        	        	    cnt297++;
        	        	} while (true);

        	        	loop297:
        	        		;	// Stops C# compiler whinging that label 'loop297' has no statements


        	        }
        	        break;
        	    case 2 :
        	        // G:\\downloads\\antlr\\cs.g:343:44: '?'
        	        {
        	        	Match(input,101,FOLLOW_101_in_synpred18_cs2460); if (state.failed) return ;

        	        }
        	        break;

        	}


        }
    }
    // $ANTLR end "synpred18_cs"

    // $ANTLR start "synpred19_cs"
    public void synpred19_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:379:2: ( unary_expression assignment_operator )
        // G:\\downloads\\antlr\\cs.g:379:3: unary_expression assignment_operator
        {
        	PushFollow(FOLLOW_unary_expression_in_synpred19_cs2642);
        	unary_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	PushFollow(FOLLOW_assignment_operator_in_synpred19_cs2646);
        	assignment_operator();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred19_cs"

    // $ANTLR start "synpred20_cs"
    public void synpred20_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:388:2: ( cast_expression )
        // G:\\downloads\\antlr\\cs.g:388:3: cast_expression
        {
        	PushFollow(FOLLOW_cast_expression_in_synpred20_cs2704);
        	cast_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred20_cs"

    // $ANTLR start "synpred21_cs"
    public void synpred21_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:414:2: ( anonymous_function_signature '=>' )
        // G:\\downloads\\antlr\\cs.g:414:3: anonymous_function_signature '=>'
        {
        	PushFollow(FOLLOW_anonymous_function_signature_in_synpred21_cs2920);
        	anonymous_function_signature();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,131,FOLLOW_131_in_synpred21_cs2924); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred21_cs"

    // $ANTLR start "synpred22_cs"
    public void synpred22_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:415:4: ( query_expression )
        // G:\\downloads\\antlr\\cs.g:415:5: query_expression
        {
        	PushFollow(FOLLOW_query_expression_in_synpred22_cs2935);
        	query_expression();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred22_cs"

    // $ANTLR start "synpred23_cs"
    public void synpred23_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:479:50: ( 'into' )
        // G:\\downloads\\antlr\\cs.g:479:51: 'into'
        {
        	Match(input,132,FOLLOW_132_in_synpred23_cs3358); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred23_cs"

    // $ANTLR start "synpred24_cs"
    public void synpred24_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:546:32: ( ',' identifier '=' )
        // G:\\downloads\\antlr\\cs.g:546:33: ',' identifier '='
        {
        	Match(input,89,FOLLOW_89_in_synpred24_cs3860); if (state.failed) return ;
        	PushFollow(FOLLOW_identifier_in_synpred24_cs3864);
        	identifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,66,FOLLOW_66_in_synpred24_cs3868); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred24_cs"

    // $ANTLR start "synpred25_cs"
    public void synpred25_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:627:4: ( member_name '{' )
        // G:\\downloads\\antlr\\cs.g:627:5: member_name '{'
        {
        	PushFollow(FOLLOW_member_name_in_synpred25_cs4386);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,62,FOLLOW_62_in_synpred25_cs4390); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred25_cs"

    // $ANTLR start "synpred26_cs"
    public void synpred26_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:734:14: ( member_name '(' )
        // G:\\downloads\\antlr\\cs.g:734:15: member_name '('
        {
        	PushFollow(FOLLOW_member_name_in_synpred26_cs5251);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,88,FOLLOW_88_in_synpred26_cs5255); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred26_cs"

    // $ANTLR start "synpred27_cs"
    public void synpred27_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:735:14: ( member_name '{' )
        // G:\\downloads\\antlr\\cs.g:735:15: member_name '{'
        {
        	PushFollow(FOLLOW_member_name_in_synpred27_cs5276);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,62,FOLLOW_62_in_synpred27_cs5280); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred27_cs"

    // $ANTLR start "synpred28_cs"
    public void synpred28_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:786:11: ( member_name '(' )
        // G:\\downloads\\antlr\\cs.g:786:12: member_name '('
        {
        	PushFollow(FOLLOW_member_name_in_synpred28_cs5724);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,88,FOLLOW_88_in_synpred28_cs5728); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred28_cs"

    // $ANTLR start "synpred29_cs"
    public void synpred29_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:787:8: ( member_name '{' )
        // G:\\downloads\\antlr\\cs.g:787:9: member_name '{'
        {
        	PushFollow(FOLLOW_member_name_in_synpred29_cs5743);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,62,FOLLOW_62_in_synpred29_cs5747); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred29_cs"

    // $ANTLR start "synpred30_cs"
    public void synpred30_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:788:8: ( member_name '.' 'this' )
        // G:\\downloads\\antlr\\cs.g:788:9: member_name '.' 'this'
        {
        	PushFollow(FOLLOW_member_name_in_synpred30_cs5762);
        	member_name();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,DOT,FOLLOW_DOT_in_synpred30_cs5766); if (state.failed) return ;
        	Match(input,83,FOLLOW_83_in_synpred30_cs5770); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred30_cs"

    // $ANTLR start "synpred31_cs"
    public void synpred31_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:860:23: ( arguments ( '[' | '.' | '->' ) )
        // G:\\downloads\\antlr\\cs.g:860:24: arguments ( '[' | '.' | '->' )
        {
        	PushFollow(FOLLOW_arguments_in_synpred31_cs6316);
        	arguments();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	if ( (input.LA(1) >= DOT && input.LA(1) <= PTR) || input.LA(1) == 86 ) 
        	{
        	    input.Consume();
        	    state.errorRecovery = false;state.failed = false;
        	}
        	else 
        	{
        	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
        	    MismatchedSetException mse = new MismatchedSetException(null,input);
        	    throw mse;
        	}


        }
    }
    // $ANTLR end "synpred31_cs"

    // $ANTLR start "synpred32_cs"
    public void synpred32_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:864:4: ( identifier '<' )
        // G:\\downloads\\antlr\\cs.g:864:5: identifier '<'
        {
        	PushFollow(FOLLOW_identifier_in_synpred32_cs6367);
        	identifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,99,FOLLOW_99_in_synpred32_cs6372); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred32_cs"

    // $ANTLR start "synpred33_cs"
    public void synpred33_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:877:2: ( declaration_statement )
        // G:\\downloads\\antlr\\cs.g:877:3: declaration_statement
        {
        	PushFollow(FOLLOW_declaration_statement_in_synpred33_cs6453);
        	declaration_statement();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred33_cs"

    // $ANTLR start "synpred34_cs"
    public void synpred34_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:878:4: ( identifier ':' )
        // G:\\downloads\\antlr\\cs.g:878:5: identifier ':'
        {
        	PushFollow(FOLLOW_identifier_in_synpred34_cs6464);
        	identifier();
        	state.followingStackPointer--;
        	if (state.failed) return ;
        	Match(input,90,FOLLOW_90_in_synpred34_cs6468); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred34_cs"

    // $ANTLR start "synpred35_cs"
    public void synpred35_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:915:2: ( 'var' )
        // G:\\downloads\\antlr\\cs.g:915:3: 'var'
        {
        	Match(input,177,FOLLOW_177_in_synpred35_cs6692); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred35_cs"

    // $ANTLR start "synpred36_cs"
    public void synpred36_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:916:4: ( 'dynamic' )
        // G:\\downloads\\antlr\\cs.g:916:5: 'dynamic'
        {
        	Match(input,178,FOLLOW_178_in_synpred36_cs6703); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred36_cs"

    // $ANTLR start "synpred37_cs"
    public void synpred37_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:942:62: ( 'else' )
        // G:\\downloads\\antlr\\cs.g:942:63: 'else'
        {
        	Match(input,180,FOLLOW_180_in_synpred37_cs6870); if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred37_cs"

    // $ANTLR start "synpred38_cs"
    public void synpred38_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:971:2: ( local_variable_declaration )
        // G:\\downloads\\antlr\\cs.g:971:3: local_variable_declaration
        {
        	PushFollow(FOLLOW_local_variable_declaration_in_synpred38_cs7121);
        	local_variable_declaration();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred38_cs"

    // $ANTLR start "synpred39_cs"
    public void synpred39_cs_fragment() {
        // G:\\downloads\\antlr\\cs.g:1023:2: ( local_variable_declaration )
        // G:\\downloads\\antlr\\cs.g:1023:3: local_variable_declaration
        {
        	PushFollow(FOLLOW_local_variable_declaration_in_synpred39_cs7534);
        	local_variable_declaration();
        	state.followingStackPointer--;
        	if (state.failed) return ;

        }
    }
    // $ANTLR end "synpred39_cs"

    // Delegated rules

   	public bool synpred24_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred24_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred9_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred9_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred19_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred19_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred2_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred2_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred15_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred15_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred4_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred4_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred12_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred12_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred32_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred32_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred29_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred29_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred18_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred18_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred16_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred16_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred10_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred10_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred5_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred5_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred28_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred28_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred17_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred17_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred14_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred14_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred6_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred6_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred25_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred25_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred37_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred37_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred31_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred31_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred22_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred22_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred11_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred11_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred7_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred7_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred34_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred34_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred23_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred23_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred36_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred36_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred21_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred21_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred13_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred13_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred8_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred8_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred33_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred33_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred26_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred26_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred30_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred30_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred38_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred38_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred35_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred35_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred3_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred3_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred39_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred39_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred1_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred1_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred27_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred27_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}
   	public bool synpred20_cs() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred20_cs_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}


   	protected DFA21 dfa21;
   	protected DFA20 dfa20;
   	protected DFA27 dfa27;
   	protected DFA29 dfa29;
   	protected DFA38 dfa38;
   	protected DFA46 dfa46;
   	protected DFA50 dfa50;
   	protected DFA71 dfa71;
   	protected DFA72 dfa72;
   	protected DFA101 dfa101;
   	protected DFA105 dfa105;
   	protected DFA107 dfa107;
   	protected DFA230 dfa230;
   	protected DFA229 dfa229;
   	protected DFA233 dfa233;
   	protected DFA241 dfa241;
   	protected DFA242 dfa242;
   	protected DFA259 dfa259;
   	protected DFA271 dfa271;
	private void InitializeCyclicDFAs()
	{
    	this.dfa21 = new DFA21(this);
    	this.dfa20 = new DFA20(this);
    	this.dfa27 = new DFA27(this);
    	this.dfa29 = new DFA29(this);
    	this.dfa38 = new DFA38(this);
    	this.dfa46 = new DFA46(this);
    	this.dfa50 = new DFA50(this);
    	this.dfa71 = new DFA71(this);
    	this.dfa72 = new DFA72(this);
    	this.dfa101 = new DFA101(this);
    	this.dfa105 = new DFA105(this);
    	this.dfa107 = new DFA107(this);
    	this.dfa230 = new DFA230(this);
    	this.dfa229 = new DFA229(this);
    	this.dfa233 = new DFA233(this);
    	this.dfa241 = new DFA241(this);
    	this.dfa242 = new DFA242(this);
    	this.dfa259 = new DFA259(this);
    	this.dfa271 = new DFA271(this);

	    this.dfa20.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA20_SpecialStateTransition);
	    this.dfa27.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA27_SpecialStateTransition);
	    this.dfa29.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA29_SpecialStateTransition);
	    this.dfa38.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA38_SpecialStateTransition);
	    this.dfa46.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA46_SpecialStateTransition);

	    this.dfa71.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA71_SpecialStateTransition);
	    this.dfa72.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA72_SpecialStateTransition);
	    this.dfa101.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA101_SpecialStateTransition);
	    this.dfa105.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA105_SpecialStateTransition);
	    this.dfa107.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA107_SpecialStateTransition);

	    this.dfa229.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA229_SpecialStateTransition);

	    this.dfa241.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA241_SpecialStateTransition);

	    this.dfa259.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA259_SpecialStateTransition);
	    this.dfa271.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA271_SpecialStateTransition);
	}

    const string DFA21_eotS =
        "\x10\uffff";
    const string DFA21_eofS =
        "\x10\uffff";
    const string DFA21_minS =
        "\x01\x04\x04\uffff\x01\x04\x01\uffff\x01\x04\x08\uffff";
    const string DFA21_maxS =
        "\x01\u00ca\x04\uffff\x01\u00ca\x01\uffff\x01\u00ca\x08\uffff";
    const string DFA21_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\uffff\x01\x06\x01"+
        "\uffff\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0d\x01\x05\x01"+
        "\x0c";
    const string DFA21_specialS =
        "\x10\uffff}>";
    static readonly string[] DFA21_transitionS = {
            "\x01\x07\x0e\uffff\x01\x0a\x2d\uffff\x01\x07\x01\uffff\x01"+
            "\x03\x0d\uffff\x01\x01\x01\x05\x0e\uffff\x01\x0b\x08\uffff\x01"+
            "\x0d\x19\uffff\x02\x07\x01\uffff\x0e\x07\x01\x02\x03\x07\x01"+
            "\uffff\x01\x07\x01\x08\x01\uffff\x03\x07\x09\x06\x01\x09\x01"+
            "\x07\x01\uffff\x01\x04\x01\uffff\x02\x0c\x01\uffff\x02\x07\x10"+
            "\uffff\x01\x07\x06\x06\x01\x07",
            "",
            "",
            "",
            "",
            "\x0a\x0e\x33\uffff\x01\x0e\x22\uffff\x01\x06\x1f\uffff\x02"+
            "\x0e\x01\uffff\x0e\x0e\x01\uffff\x03\x0e\x01\uffff\x01\x0e\x02"+
            "\uffff\x0c\x0e\x01\uffff\x01\x0e\x06\uffff\x02\x0e\x10\uffff"+
            "\x08\x0e",
            "",
            "\x0b\x06\x32\uffff\x01\x06\x11\uffff\x02\x06\x01\uffff\x01"+
            "\x06\x01\uffff\x01\x0f\x0a\uffff\x03\x06\x1e\uffff\x02\x06\x01"+
            "\uffff\x0e\x06\x01\uffff\x03\x06\x01\uffff\x01\x06\x02\uffff"+
            "\x0c\x06\x01\uffff\x01\x06\x02\uffff\x01\x06\x03\uffff\x02\x06"+
            "\x10\uffff\x08\x06",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA21_eot = DFA.UnpackEncodedString(DFA21_eotS);
    static readonly short[] DFA21_eof = DFA.UnpackEncodedString(DFA21_eofS);
    static readonly char[] DFA21_min = DFA.UnpackEncodedStringToUnsignedChars(DFA21_minS);
    static readonly char[] DFA21_max = DFA.UnpackEncodedStringToUnsignedChars(DFA21_maxS);
    static readonly short[] DFA21_accept = DFA.UnpackEncodedString(DFA21_acceptS);
    static readonly short[] DFA21_special = DFA.UnpackEncodedString(DFA21_specialS);
    static readonly short[][] DFA21_transition = DFA.UnpackEncodedStringArray(DFA21_transitionS);

    protected class DFA21 : DFA
    {
        public DFA21(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 21;
            this.eot = DFA21_eot;
            this.eof = DFA21_eof;
            this.min = DFA21_min;
            this.max = DFA21_max;
            this.accept = DFA21_accept;
            this.special = DFA21_special;
            this.transition = DFA21_transition;

        }

        override public string Description
        {
            get { return "91:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | class_declaration | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration | destructor_declaration )"; }
        }

    }

    const string DFA20_eotS =
        "\x0a\uffff";
    const string DFA20_eofS =
        "\x0a\uffff";
    const string DFA20_minS =
        "\x01\x04\x03\x00\x06\uffff";
    const string DFA20_maxS =
        "\x01\u00ca\x03\x00\x06\uffff";
    const string DFA20_acceptS =
        "\x04\uffff\x01\x04\x01\x06\x01\x01\x01\x02\x01\x03\x01\x05";
    const string DFA20_specialS =
        "\x01\uffff\x01\x00\x01\x01\x01\x02\x06\uffff}>";
    static readonly string[] DFA20_transitionS = {
            "\x01\x02\x09\x03\x33\uffff\x01\x02\x11\uffff\x01\x04\x30\uffff"+
            "\x02\x02\x01\uffff\x0e\x02\x01\uffff\x03\x02\x01\uffff\x01\x02"+
            "\x02\uffff\x03\x02\x09\x01\x01\uffff\x01\x02\x02\uffff\x01\x05"+
            "\x03\uffff\x02\x02\x10\uffff\x01\x02\x06\x01\x01\x02",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA20_eot = DFA.UnpackEncodedString(DFA20_eotS);
    static readonly short[] DFA20_eof = DFA.UnpackEncodedString(DFA20_eofS);
    static readonly char[] DFA20_min = DFA.UnpackEncodedStringToUnsignedChars(DFA20_minS);
    static readonly char[] DFA20_max = DFA.UnpackEncodedStringToUnsignedChars(DFA20_maxS);
    static readonly short[] DFA20_accept = DFA.UnpackEncodedString(DFA20_acceptS);
    static readonly short[] DFA20_special = DFA.UnpackEncodedString(DFA20_specialS);
    static readonly short[][] DFA20_transition = DFA.UnpackEncodedStringArray(DFA20_transitionS);

    protected class DFA20 : DFA
    {
        public DFA20(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 20;
            this.eot = DFA20_eot;
            this.eof = DFA20_eof;
            this.min = DFA20_min;
            this.max = DFA20_max;
            this.accept = DFA20_accept;
            this.special = DFA20_special;
            this.transition = DFA20_transition;

        }

        override public string Description
        {
            get { return "99:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )"; }
        }

    }


    protected internal int DFA20_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA20_1 = input.LA(1);

                   	 
                   	int index20_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred2_cs()) ) { s = 6; }

                   	else if ( (synpred3_cs()) ) { s = 7; }

                   	 
                   	input.Seek(index20_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA20_2 = input.LA(1);

                   	 
                   	int index20_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred2_cs()) ) { s = 6; }

                   	else if ( (synpred3_cs()) ) { s = 7; }

                   	else if ( (synpred4_cs()) ) { s = 8; }

                   	else if ( (true) ) { s = 9; }

                   	 
                   	input.Seek(index20_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA20_3 = input.LA(1);

                   	 
                   	int index20_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred2_cs()) ) { s = 6; }

                   	else if ( (synpred3_cs()) ) { s = 7; }

                   	 
                   	input.Seek(index20_3);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 20, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA27_eotS =
        "\x10\uffff";
    const string DFA27_eofS =
        "\x10\uffff";
    const string DFA27_minS =
        "\x01\x04\x01\x00\x0e\uffff";
    const string DFA27_maxS =
        "\x01\u00ca\x01\x00\x0e\uffff";
    const string DFA27_acceptS =
        "\x02\uffff\x01\x03\x05\uffff\x01\x04\x01\x05\x01\x06\x01\x07\x01"+
        "\x08\x01\x09\x01\x01\x01\x02";
    const string DFA27_specialS =
        "\x01\uffff\x01\x00\x0e\uffff}>";
    static readonly string[] DFA27_transitionS = {
            "\x0a\x02\x33\uffff\x01\x02\x02\uffff\x01\x08\x0e\uffff\x01"+
            "\x01\x01\uffff\x01\x02\x02\uffff\x01\x02\x04\uffff\x01\x09\x01"+
            "\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x02\x21\uffff\x02\x02\x01\uffff"+
            "\x0e\x02\x01\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff\x0c\x02"+
            "\x01\uffff\x01\x02\x06\uffff\x02\x02\x10\uffff\x08\x02",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA27_eot = DFA.UnpackEncodedString(DFA27_eotS);
    static readonly short[] DFA27_eof = DFA.UnpackEncodedString(DFA27_eofS);
    static readonly char[] DFA27_min = DFA.UnpackEncodedStringToUnsignedChars(DFA27_minS);
    static readonly char[] DFA27_max = DFA.UnpackEncodedStringToUnsignedChars(DFA27_maxS);
    static readonly short[] DFA27_accept = DFA.UnpackEncodedString(DFA27_acceptS);
    static readonly short[] DFA27_special = DFA.UnpackEncodedString(DFA27_specialS);
    static readonly short[][] DFA27_transition = DFA.UnpackEncodedStringArray(DFA27_transitionS);

    protected class DFA27 : DFA
    {
        public DFA27(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 27;
            this.eot = DFA27_eot;
            this.eof = DFA27_eof;
            this.min = DFA27_min;
            this.max = DFA27_max;
            this.accept = DFA27_accept;
            this.special = DFA27_special;
            this.transition = DFA27_transition;

        }

        override public string Description
        {
            get { return "118:1: primary_expression : ( ( 'this' brackets )=> 'this' brackets ( primary_expression_part )* | ( 'base' brackets )=> 'this' brackets ( primary_expression_part )* | primary_expression_start ( primary_expression_part )* | 'new' ( ( object_creation_expression ( '.' | '->' | '[' ) )=> object_creation_expression ( primary_expression_part )+ | ( delegate_creation_expression )=> delegate_creation_expression | object_creation_expression | anonymous_object_creation_expression ) | sizeof_expression | checked_expression | unchecked_expression | default_value_expression | anonymous_method_expression );"; }
        }

    }


    protected internal int DFA27_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA27_1 = input.LA(1);

                   	 
                   	int index27_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred5_cs()) ) { s = 14; }

                   	else if ( (synpred6_cs()) ) { s = 15; }

                   	else if ( (true) ) { s = 2; }

                   	 
                   	input.Seek(index27_1);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 27, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA29_eotS =
        "\x0a\uffff";
    const string DFA29_eofS =
        "\x0a\uffff";
    const string DFA29_minS =
        "\x01\x04\x01\uffff\x01\x00\x07\uffff";
    const string DFA29_maxS =
        "\x01\u00ca\x01\uffff\x01\x00\x07\uffff";
    const string DFA29_acceptS =
        "\x01\uffff\x01\x01\x01\uffff\x01\x04\x01\x05\x01\x06\x01\x07\x01"+
        "\x08\x01\x02\x01\x03";
    const string DFA29_specialS =
        "\x02\uffff\x01\x00\x07\uffff}>";
    static readonly string[] DFA29_transitionS = {
            "\x01\x02\x09\x07\x33\uffff\x01\x02\x11\uffff\x01\x03\x01\uffff"+
            "\x01\x04\x02\uffff\x01\x05\x09\uffff\x01\x06\x21\uffff\x02\x02"+
            "\x01\uffff\x0e\x02\x01\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff"+
            "\x03\x02\x09\x01\x01\uffff\x01\x02\x06\uffff\x02\x02\x10\uffff"+
            "\x01\x02\x06\x01\x01\x02",
            "",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA29_eot = DFA.UnpackEncodedString(DFA29_eotS);
    static readonly short[] DFA29_eof = DFA.UnpackEncodedString(DFA29_eofS);
    static readonly char[] DFA29_min = DFA.UnpackEncodedStringToUnsignedChars(DFA29_minS);
    static readonly char[] DFA29_max = DFA.UnpackEncodedStringToUnsignedChars(DFA29_maxS);
    static readonly short[] DFA29_accept = DFA.UnpackEncodedString(DFA29_acceptS);
    static readonly short[] DFA29_special = DFA.UnpackEncodedString(DFA29_specialS);
    static readonly short[][] DFA29_transition = DFA.UnpackEncodedStringArray(DFA29_transitionS);

    protected class DFA29 : DFA
    {
        public DFA29(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 29;
            this.eot = DFA29_eot;
            this.eof = DFA29_eof;
            this.min = DFA29_min;
            this.max = DFA29_max;
            this.accept = DFA29_accept;
            this.special = DFA29_special;
            this.transition = DFA29_transition;

        }

        override public string Description
        {
            get { return "136:1: primary_expression_start : ( predefined_type | ( identifier '<' )=> identifier generic_argument_list | identifier ( '::' identifier )? | 'this' | 'base' | paren_expression | typeof_expression | literal );"; }
        }

    }


    protected internal int DFA29_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA29_2 = input.LA(1);

                   	 
                   	int index29_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred9_cs()) ) { s = 8; }

                   	else if ( (true) ) { s = 9; }

                   	 
                   	input.Seek(index29_2);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 29, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA38_eotS =
        "\x18\uffff";
    const string DFA38_eofS =
        "\x18\uffff";
    const string DFA38_minS =
        "\x01\x04\x01\x00\x16\uffff";
    const string DFA38_maxS =
        "\x01\u00ca\x01\x00\x16\uffff";
    const string DFA38_acceptS =
        "\x02\uffff\x01\x02\x14\uffff\x01\x01";
    const string DFA38_specialS =
        "\x01\uffff\x01\x00\x16\uffff}>";
    static readonly string[] DFA38_transitionS = {
            "\x0a\x02\x02\uffff\x01\x02\x30\uffff\x01\x02\x02\uffff\x01"+
            "\x02\x0e\uffff\x01\x02\x01\uffff\x01\x02\x02\uffff\x01\x01\x04"+
            "\uffff\x06\x02\x01\uffff\x01\x02\x01\uffff\x05\x02\x0a\uffff"+
            "\x01\x02\x0e\uffff\x02\x02\x01\uffff\x0e\x02\x01\uffff\x03\x02"+
            "\x01\uffff\x01\x02\x02\uffff\x0c\x02\x01\uffff\x01\x02\x06\uffff"+
            "\x02\x02\x10\uffff\x08\x02",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA38_eot = DFA.UnpackEncodedString(DFA38_eotS);
    static readonly short[] DFA38_eof = DFA.UnpackEncodedString(DFA38_eofS);
    static readonly char[] DFA38_min = DFA.UnpackEncodedStringToUnsignedChars(DFA38_minS);
    static readonly char[] DFA38_max = DFA.UnpackEncodedStringToUnsignedChars(DFA38_maxS);
    static readonly short[] DFA38_accept = DFA.UnpackEncodedString(DFA38_acceptS);
    static readonly short[] DFA38_special = DFA.UnpackEncodedString(DFA38_specialS);
    static readonly short[][] DFA38_transition = DFA.UnpackEncodedStringArray(DFA38_transitionS);

    protected class DFA38 : DFA
    {
        public DFA38(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 38;
            this.eot = DFA38_eot;
            this.eof = DFA38_eof;
            this.min = DFA38_min;
            this.max = DFA38_max;
            this.accept = DFA38_accept;
            this.special = DFA38_special;
            this.transition = DFA38_transition;

        }

        override public string Description
        {
            get { return "176:3: ( ( '(' type ')' )=> '(' type ')' ( ref_variable_reference | variable_reference ) | variable_reference )"; }
        }

    }


    protected internal int DFA38_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA38_1 = input.LA(1);

                   	 
                   	int index38_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred10_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 2; }

                   	 
                   	input.Seek(index38_1);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 38, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA46_eotS =
        "\x0f\uffff";
    const string DFA46_eofS =
        "\x0f\uffff";
    const string DFA46_minS =
        "\x01\x04\x01\x00\x0d\uffff";
    const string DFA46_maxS =
        "\x01\u00ca\x01\x00\x0d\uffff";
    const string DFA46_acceptS =
        "\x02\uffff\x01\x02\x0b\uffff\x01\x01";
    const string DFA46_specialS =
        "\x01\uffff\x01\x00\x0d\uffff}>";
    static readonly string[] DFA46_transitionS = {
            "\x0a\x02\x33\uffff\x01\x02\x02\uffff\x01\x01\x0e\uffff\x01"+
            "\x02\x01\uffff\x01\x02\x02\uffff\x01\x02\x04\uffff\x06\x02\x21"+
            "\uffff\x02\x02\x01\uffff\x0e\x02\x01\uffff\x03\x02\x01\uffff"+
            "\x01\x02\x02\uffff\x0c\x02\x01\uffff\x01\x02\x06\uffff\x02\x02"+
            "\x10\uffff\x08\x02",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA46_eot = DFA.UnpackEncodedString(DFA46_eotS);
    static readonly short[] DFA46_eof = DFA.UnpackEncodedString(DFA46_eofS);
    static readonly char[] DFA46_min = DFA.UnpackEncodedStringToUnsignedChars(DFA46_minS);
    static readonly char[] DFA46_max = DFA.UnpackEncodedStringToUnsignedChars(DFA46_maxS);
    static readonly short[] DFA46_accept = DFA.UnpackEncodedString(DFA46_acceptS);
    static readonly short[] DFA46_special = DFA.UnpackEncodedString(DFA46_specialS);
    static readonly short[][] DFA46_transition = DFA.UnpackEncodedStringArray(DFA46_transitionS);

    protected class DFA46 : DFA
    {
        public DFA46(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 46;
            this.eot = DFA46_eot;
            this.eof = DFA46_eof;
            this.min = DFA46_min;
            this.max = DFA46_max;
            this.accept = DFA46_accept;
            this.special = DFA46_special;
            this.transition = DFA46_transition;

        }

        override public string Description
        {
            get { return "203:1: primary_or_array_creation_expression : ( ( array_creation_expression )=> array_creation_expression | primary_expression );"; }
        }

    }


    protected internal int DFA46_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA46_1 = input.LA(1);

                   	 
                   	int index46_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred11_cs()) ) { s = 14; }

                   	else if ( (true) ) { s = 2; }

                   	 
                   	input.Seek(index46_1);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 46, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA50_eotS =
        "\x05\uffff";
    const string DFA50_eofS =
        "\x01\x02\x03\uffff\x01\x02";
    const string DFA50_minS =
        "\x02\x04\x02\uffff\x01\x04";
    const string DFA50_maxS =
        "\x02\u00ca\x02\uffff\x01\u00ca";
    const string DFA50_acceptS =
        "\x02\uffff\x01\x01\x01\x02\x01\uffff";
    const string DFA50_specialS =
        "\x05\uffff}>";
    static readonly string[] DFA50_transitionS = {
            "\x01\x02\x09\uffff\x02\x03\x02\x02\x07\uffff\x02\x02\x23\uffff"+
            "\x02\x02\x01\uffff\x02\x02\x13\uffff\x01\x01\x01\x02\x01\x03"+
            "\x02\x02\x08\uffff\x06\x02\x02\uffff\x18\x02\x01\uffff\x02\x02"+
            "\x01\uffff\x0e\x02\x01\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff"+
            "\x03\x02\x0a\uffff\x01\x02\x06\uffff\x02\x02\x10\uffff\x01\x02"+
            "\x06\uffff\x01\x02",
            "\x0a\x03\x02\uffff\x01\x03\x30\uffff\x01\x03\x02\uffff\x01"+
            "\x03\x0e\uffff\x01\x03\x01\uffff\x01\x03\x01\uffff\x01\x04\x01"+
            "\x03\x01\x02\x03\uffff\x06\x03\x01\uffff\x01\x03\x01\uffff\x05"+
            "\x03\x0a\uffff\x01\x03\x0e\uffff\x02\x03\x01\uffff\x0e\x03\x01"+
            "\uffff\x03\x03\x01\uffff\x01\x03\x02\uffff\x0c\x03\x01\uffff"+
            "\x01\x03\x06\uffff\x02\x03\x10\uffff\x08\x03",
            "",
            "",
            "\x01\x02\x09\uffff\x02\x03\x02\x02\x07\uffff\x02\x02\x23\uffff"+
            "\x02\x02\x01\uffff\x02\x02\x13\uffff\x01\x01\x01\x02\x01\x03"+
            "\x02\x02\x08\uffff\x06\x02\x02\uffff\x18\x02\x01\uffff\x02\x02"+
            "\x01\uffff\x0e\x02\x01\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff"+
            "\x03\x02\x0a\uffff\x01\x02\x06\uffff\x02\x02\x10\uffff\x01\x02"+
            "\x06\uffff\x01\x02"
    };

    static readonly short[] DFA50_eot = DFA.UnpackEncodedString(DFA50_eotS);
    static readonly short[] DFA50_eof = DFA.UnpackEncodedString(DFA50_eofS);
    static readonly char[] DFA50_min = DFA.UnpackEncodedStringToUnsignedChars(DFA50_minS);
    static readonly char[] DFA50_max = DFA.UnpackEncodedStringToUnsignedChars(DFA50_maxS);
    static readonly short[] DFA50_accept = DFA.UnpackEncodedString(DFA50_acceptS);
    static readonly short[] DFA50_special = DFA.UnpackEncodedString(DFA50_specialS);
    static readonly short[][] DFA50_transition = DFA.UnpackEncodedStringArray(DFA50_transitionS);

    protected class DFA50 : DFA
    {
        public DFA50(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 50;
            this.eot = DFA50_eot;
            this.eof = DFA50_eof;
            this.min = DFA50_min;
            this.max = DFA50_max;
            this.accept = DFA50_accept;
            this.special = DFA50_special;
            this.transition = DFA50_transition;

        }

        override public string Description
        {
            get { return "211:6: ( ( rank_specifiers )? ( array_initializer )? | ( ( ( arguments ( '[' | '.' | '->' ) )=> arguments invocation_part ) | invocation_part )* arguments )"; }
        }

    }

    const string DFA71_eotS =
        "\x0e\uffff";
    const string DFA71_eofS =
        "\x0e\uffff";
    const string DFA71_minS =
        "\x01\x04\x01\x0e\x01\uffff\x01\x1a\x03\x04\x01\uffff\x02\x0e\x02"+
        "\uffff\x02\x04";
    const string DFA71_maxS =
        "\x01\u00ca\x01\x65\x01\uffff\x01\x64\x03\u00ca\x01\uffff\x02\x65"+
        "\x02\uffff\x02\u00ca";
    const string DFA71_acceptS =
        "\x02\uffff\x01\x02\x04\uffff\x01\x03\x02\uffff\x02\x01\x02\uffff";
    const string DFA71_specialS =
        "\x06\uffff\x01\x02\x05\uffff\x01\x01\x01\x00}>";
    static readonly string[] DFA71_transitionS = {
            "\x01\x01\x3c\uffff\x01\x01\x10\uffff\x01\x03\x31\uffff\x02"+
            "\x01\x01\uffff\x0e\x01\x01\uffff\x03\x01\x01\uffff\x01\x01\x02"+
            "\uffff\x03\x01\x09\x02\x01\uffff\x01\x01\x06\uffff\x02\x01\x10"+
            "\uffff\x01\x01\x06\x02\x01\x01",
            "\x01\x05\x0b\uffff\x01\x02\x39\uffff\x01\x04\x01\uffff\x01"+
            "\x02\x0c\uffff\x01\x06\x02\x02",
            "",
            "\x01\x07\x49\uffff\x01\x02",
            "\x01\x08\x3c\uffff\x01\x08\x42\uffff\x02\x08\x01\uffff\x0e"+
            "\x08\x01\uffff\x03\x08\x01\uffff\x01\x08\x02\uffff\x03\x08\x0a"+
            "\uffff\x01\x08\x06\uffff\x02\x08\x10\uffff\x01\x08\x06\uffff"+
            "\x01\x08",
            "\x01\x09\x3c\uffff\x01\x09\x42\uffff\x02\x09\x01\uffff\x0e"+
            "\x09\x01\uffff\x03\x09\x01\uffff\x01\x09\x02\uffff\x03\x09\x0a"+
            "\uffff\x01\x09\x06\uffff\x02\x09\x10\uffff\x01\x09\x06\uffff"+
            "\x01\x09",
            "\x01\x02\x0c\uffff\x01\x0b\x2f\uffff\x01\x02\x10\uffff\x01"+
            "\x02\x06\uffff\x01\x0a\x2a\uffff\x02\x02\x01\uffff\x0e\x02\x01"+
            "\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff\x0c\x02\x01\uffff"+
            "\x01\x02\x06\uffff\x02\x02\x10\uffff\x08\x02",
            "",
            "\x01\x05\x0b\uffff\x01\x02\x3b\uffff\x01\x02\x0c\uffff\x01"+
            "\x0c\x02\x02",
            "\x01\x05\x0b\uffff\x01\x02\x3b\uffff\x01\x02\x0c\uffff\x01"+
            "\x0d\x02\x02",
            "",
            "",
            "\x01\x02\x0c\uffff\x01\x0b\x2f\uffff\x01\x02\x10\uffff\x01"+
            "\x02\x06\uffff\x01\x0a\x2a\uffff\x02\x02\x01\uffff\x0e\x02\x01"+
            "\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff\x0c\x02\x01\uffff"+
            "\x01\x02\x06\uffff\x02\x02\x10\uffff\x08\x02",
            "\x01\x02\x0c\uffff\x01\x0b\x2f\uffff\x01\x02\x10\uffff\x01"+
            "\x02\x06\uffff\x01\x0a\x2a\uffff\x02\x02\x01\uffff\x0e\x02\x01"+
            "\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff\x0c\x02\x01\uffff"+
            "\x01\x02\x06\uffff\x02\x02\x10\uffff\x08\x02"
    };

    static readonly short[] DFA71_eot = DFA.UnpackEncodedString(DFA71_eotS);
    static readonly short[] DFA71_eof = DFA.UnpackEncodedString(DFA71_eofS);
    static readonly char[] DFA71_min = DFA.UnpackEncodedStringToUnsignedChars(DFA71_minS);
    static readonly char[] DFA71_max = DFA.UnpackEncodedStringToUnsignedChars(DFA71_maxS);
    static readonly short[] DFA71_accept = DFA.UnpackEncodedString(DFA71_acceptS);
    static readonly short[] DFA71_special = DFA.UnpackEncodedString(DFA71_specialS);
    static readonly short[][] DFA71_transition = DFA.UnpackEncodedStringArray(DFA71_transitionS);

    protected class DFA71 : DFA
    {
        public DFA71(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 71;
            this.eot = DFA71_eot;
            this.eof = DFA71_eof;
            this.min = DFA71_min;
            this.max = DFA71_max;
            this.accept = DFA71_accept;
            this.special = DFA71_special;
            this.transition = DFA71_transition;

        }

        override public string Description
        {
            get { return "284:19: ( ( unbound_type_name )=> unbound_type_name | type | 'void' )"; }
        }

    }


    protected internal int DFA71_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA71_13 = input.LA(1);

                   	 
                   	int index71_13 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA71_13 == 89) && (synpred13_cs()) ) { s = 10; }

                   	else if ( (LA71_13 == GT) && (synpred13_cs()) ) { s = 11; }

                   	else if ( (LA71_13 == IDENTIFIER || LA71_13 == 65 || LA71_13 == 82 || (LA71_13 >= 132 && LA71_13 <= 133) || (LA71_13 >= 135 && LA71_13 <= 148) || (LA71_13 >= 150 && LA71_13 <= 152) || LA71_13 == 154 || (LA71_13 >= 157 && LA71_13 <= 168) || LA71_13 == 170 || (LA71_13 >= 177 && LA71_13 <= 178) || (LA71_13 >= 195 && LA71_13 <= 202)) ) { s = 2; }

                   	 
                   	input.Seek(index71_13);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA71_12 = input.LA(1);

                   	 
                   	int index71_12 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA71_12 == 89) && (synpred13_cs()) ) { s = 10; }

                   	else if ( (LA71_12 == GT) && (synpred13_cs()) ) { s = 11; }

                   	else if ( (LA71_12 == IDENTIFIER || LA71_12 == 65 || LA71_12 == 82 || (LA71_12 >= 132 && LA71_12 <= 133) || (LA71_12 >= 135 && LA71_12 <= 148) || (LA71_12 >= 150 && LA71_12 <= 152) || LA71_12 == 154 || (LA71_12 >= 157 && LA71_12 <= 168) || LA71_12 == 170 || (LA71_12 >= 177 && LA71_12 <= 178) || (LA71_12 >= 195 && LA71_12 <= 202)) ) { s = 2; }

                   	 
                   	input.Seek(index71_12);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA71_6 = input.LA(1);

                   	 
                   	int index71_6 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA71_6 == 89) && (synpred13_cs()) ) { s = 10; }

                   	else if ( (LA71_6 == GT) && (synpred13_cs()) ) { s = 11; }

                   	else if ( (LA71_6 == IDENTIFIER || LA71_6 == 65 || LA71_6 == 82 || (LA71_6 >= 132 && LA71_6 <= 133) || (LA71_6 >= 135 && LA71_6 <= 148) || (LA71_6 >= 150 && LA71_6 <= 152) || LA71_6 == 154 || (LA71_6 >= 157 && LA71_6 <= 168) || LA71_6 == 170 || (LA71_6 >= 177 && LA71_6 <= 178) || (LA71_6 >= 195 && LA71_6 <= 202)) ) { s = 2; }

                   	 
                   	input.Seek(index71_6);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 71, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA72_eotS =
        "\x07\uffff";
    const string DFA72_eofS =
        "\x04\uffff\x01\x06\x02\uffff";
    const string DFA72_minS =
        "\x01\x0e\x01\x11\x01\uffff\x01\x11\x01\x0e\x02\uffff";
    const string DFA72_maxS =
        "\x01\x63\x01\x59\x01\uffff\x01\x59\x01\x1a\x02\uffff";
    const string DFA72_acceptS =
        "\x02\uffff\x01\x02\x02\uffff\x01\x01\x01\x03";
    const string DFA72_specialS =
        "\x04\uffff\x01\x00\x02\uffff}>";
    static readonly string[] DFA72_transitionS = {
            "\x01\x02\x54\uffff\x01\x01",
            "\x01\x04\x47\uffff\x01\x03",
            "",
            "\x01\x04\x47\uffff\x01\x03",
            "\x01\x05\x0b\uffff\x01\x06",
            "",
            ""
    };

    static readonly short[] DFA72_eot = DFA.UnpackEncodedString(DFA72_eotS);
    static readonly short[] DFA72_eof = DFA.UnpackEncodedString(DFA72_eofS);
    static readonly char[] DFA72_min = DFA.UnpackEncodedStringToUnsignedChars(DFA72_minS);
    static readonly char[] DFA72_max = DFA.UnpackEncodedStringToUnsignedChars(DFA72_maxS);
    static readonly short[] DFA72_accept = DFA.UnpackEncodedString(DFA72_acceptS);
    static readonly short[] DFA72_special = DFA.UnpackEncodedString(DFA72_specialS);
    static readonly short[][] DFA72_transition = DFA.UnpackEncodedStringArray(DFA72_transitionS);

    protected class DFA72 : DFA
    {
        public DFA72(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 72;
            this.eot = DFA72_eot;
            this.eof = DFA72_eof;
            this.min = DFA72_min;
            this.max = DFA72_max;
            this.accept = DFA72_accept;
            this.special = DFA72_special;
            this.transition = DFA72_transition;

        }

        override public string Description
        {
            get { return "()* loopback of 294:3: ( ( ( generic_dimension_specifier '.' )=> generic_dimension_specifier unbound_type_name_part ) | unbound_type_name_part )*"; }
        }

    }


    protected internal int DFA72_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA72_4 = input.LA(1);

                   	 
                   	int index72_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA72_4 == DOT) && (synpred14_cs()) ) { s = 5; }

                   	else if ( (LA72_4 == EOF || LA72_4 == RPAREN) ) { s = 6; }

                   	 
                   	input.Seek(index72_4);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 72, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA101_eotS =
        "\x19\uffff";
    const string DFA101_eofS =
        "\x19\uffff";
    const string DFA101_minS =
        "\x01\x04\x16\x00\x02\uffff";
    const string DFA101_maxS =
        "\x01\u00ca\x16\x00\x02\uffff";
    const string DFA101_acceptS =
        "\x17\uffff\x01\x01\x01\x02";
    const string DFA101_specialS =
        "\x01\uffff\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01"+
        "\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01"+
        "\x0e\x01\x0f\x01\x10\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x02"+
        "\uffff}>";
    static readonly string[] DFA101_transitionS = {
            "\x01\x16\x09\x08\x02\uffff\x01\x0f\x30\uffff\x01\x16\x02\uffff"+
            "\x01\x02\x0e\uffff\x01\x03\x01\uffff\x01\x06\x02\uffff\x01\x01"+
            "\x04\uffff\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x07\x01"+
            "\uffff\x01\x14\x01\uffff\x01\x12\x01\x13\x01\x0e\x01\x10\x01"+
            "\x11\x0a\uffff\x01\x15\x0e\uffff\x01\x16\x01\x05\x01\uffff\x0e"+
            "\x16\x01\uffff\x03\x16\x01\uffff\x01\x16\x02\uffff\x03\x16\x09"+
            "\x04\x01\uffff\x01\x16\x06\uffff\x02\x16\x10\uffff\x01\x16\x06"+
            "\x04\x01\x16",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            ""
    };

    static readonly short[] DFA101_eot = DFA.UnpackEncodedString(DFA101_eotS);
    static readonly short[] DFA101_eof = DFA.UnpackEncodedString(DFA101_eofS);
    static readonly char[] DFA101_min = DFA.UnpackEncodedStringToUnsignedChars(DFA101_minS);
    static readonly char[] DFA101_max = DFA.UnpackEncodedStringToUnsignedChars(DFA101_maxS);
    static readonly short[] DFA101_accept = DFA.UnpackEncodedString(DFA101_acceptS);
    static readonly short[] DFA101_special = DFA.UnpackEncodedString(DFA101_specialS);
    static readonly short[][] DFA101_transition = DFA.UnpackEncodedStringArray(DFA101_transitionS);

    protected class DFA101 : DFA
    {
        public DFA101(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 101;
            this.eot = DFA101_eot;
            this.eof = DFA101_eof;
            this.min = DFA101_min;
            this.max = DFA101_max;
            this.accept = DFA101_accept;
            this.special = DFA101_special;
            this.transition = DFA101_transition;

        }

        override public string Description
        {
            get { return "378:1: expression : ( ( unary_expression assignment_operator )=> assignment | non_assignment_expression );"; }
        }

    }


    protected internal int DFA101_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA101_1 = input.LA(1);

                   	 
                   	int index101_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA101_2 = input.LA(1);

                   	 
                   	int index101_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA101_3 = input.LA(1);

                   	 
                   	int index101_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_3);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA101_4 = input.LA(1);

                   	 
                   	int index101_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA101_5 = input.LA(1);

                   	 
                   	int index101_5 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_5);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA101_6 = input.LA(1);

                   	 
                   	int index101_6 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_6);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 6 : 
                   	int LA101_7 = input.LA(1);

                   	 
                   	int index101_7 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_7);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 7 : 
                   	int LA101_8 = input.LA(1);

                   	 
                   	int index101_8 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_8);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 8 : 
                   	int LA101_9 = input.LA(1);

                   	 
                   	int index101_9 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_9);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 9 : 
                   	int LA101_10 = input.LA(1);

                   	 
                   	int index101_10 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_10);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 10 : 
                   	int LA101_11 = input.LA(1);

                   	 
                   	int index101_11 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_11);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 11 : 
                   	int LA101_12 = input.LA(1);

                   	 
                   	int index101_12 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_12);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 12 : 
                   	int LA101_13 = input.LA(1);

                   	 
                   	int index101_13 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_13);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 13 : 
                   	int LA101_14 = input.LA(1);

                   	 
                   	int index101_14 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_14);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 14 : 
                   	int LA101_15 = input.LA(1);

                   	 
                   	int index101_15 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_15);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 15 : 
                   	int LA101_16 = input.LA(1);

                   	 
                   	int index101_16 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_16);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 16 : 
                   	int LA101_17 = input.LA(1);

                   	 
                   	int index101_17 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_17);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 17 : 
                   	int LA101_18 = input.LA(1);

                   	 
                   	int index101_18 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_18);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 18 : 
                   	int LA101_19 = input.LA(1);

                   	 
                   	int index101_19 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_19);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 19 : 
                   	int LA101_20 = input.LA(1);

                   	 
                   	int index101_20 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_20);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 20 : 
                   	int LA101_21 = input.LA(1);

                   	 
                   	int index101_21 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_21);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 21 : 
                   	int LA101_22 = input.LA(1);

                   	 
                   	int index101_22 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred19_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 24; }

                   	 
                   	input.Seek(index101_22);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 101, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA105_eotS =
        "\x17\uffff";
    const string DFA105_eofS =
        "\x17\uffff";
    const string DFA105_minS =
        "\x01\x04\x01\x00\x15\uffff";
    const string DFA105_maxS =
        "\x01\u00ca\x01\x00\x15\uffff";
    const string DFA105_acceptS =
        "\x02\uffff\x01\x02\x0b\uffff\x01\x03\x01\x04\x01\x05\x01\x06\x01"+
        "\x07\x01\x08\x01\x09\x01\x0a\x01\x01";
    const string DFA105_specialS =
        "\x01\uffff\x01\x00\x15\uffff}>";
    static readonly string[] DFA105_transitionS = {
            "\x0a\x02\x02\uffff\x01\x0f\x30\uffff\x01\x02\x02\uffff\x01"+
            "\x02\x0e\uffff\x01\x02\x01\uffff\x01\x02\x02\uffff\x01\x01\x04"+
            "\uffff\x06\x02\x01\uffff\x01\x14\x01\uffff\x01\x12\x01\x13\x01"+
            "\x0e\x01\x10\x01\x11\x0a\uffff\x01\x15\x0e\uffff\x02\x02\x01"+
            "\uffff\x0e\x02\x01\uffff\x03\x02\x01\uffff\x01\x02\x02\uffff"+
            "\x0c\x02\x01\uffff\x01\x02\x06\uffff\x02\x02\x10\uffff\x08\x02",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA105_eot = DFA.UnpackEncodedString(DFA105_eotS);
    static readonly short[] DFA105_eof = DFA.UnpackEncodedString(DFA105_eofS);
    static readonly char[] DFA105_min = DFA.UnpackEncodedStringToUnsignedChars(DFA105_minS);
    static readonly char[] DFA105_max = DFA.UnpackEncodedStringToUnsignedChars(DFA105_maxS);
    static readonly short[] DFA105_accept = DFA.UnpackEncodedString(DFA105_acceptS);
    static readonly short[] DFA105_special = DFA.UnpackEncodedString(DFA105_specialS);
    static readonly short[][] DFA105_transition = DFA.UnpackEncodedStringArray(DFA105_transitionS);

    protected class DFA105 : DFA
    {
        public DFA105(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 105;
            this.eot = DFA105_eot;
            this.eof = DFA105_eof;
            this.min = DFA105_min;
            this.max = DFA105_max;
            this.accept = DFA105_accept;
            this.special = DFA105_special;
            this.transition = DFA105_transition;

        }

        override public string Description
        {
            get { return "386:1: unary_expression : ( ( cast_expression )=> cast_expression | primary_or_array_creation_expression ( '++' )? ( '--' )? | '+' unary_expression | '-' unary_expression | '!' unary_expression | '~' unary_expression | pre_increment_expression | pre_decrement_expression | pointer_indirection_expression | addressof_expression );"; }
        }

    }


    protected internal int DFA105_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA105_1 = input.LA(1);

                   	 
                   	int index105_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred20_cs()) ) { s = 22; }

                   	else if ( (true) ) { s = 2; }

                   	 
                   	input.Seek(index105_1);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 105, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA107_eotS =
        "\x19\uffff";
    const string DFA107_eofS =
        "\x19\uffff";
    const string DFA107_minS =
        "\x01\x04\x03\x00\x15\uffff";
    const string DFA107_maxS =
        "\x01\u00ca\x03\x00\x15\uffff";
    const string DFA107_acceptS =
        "\x04\uffff\x01\x03\x12\uffff\x01\x01\x01\x02";
    const string DFA107_specialS =
        "\x01\uffff\x01\x00\x01\x01\x01\x02\x15\uffff}>";
    static readonly string[] DFA107_transitionS = {
            "\x01\x03\x09\x04\x02\uffff\x01\x04\x30\uffff\x01\x03\x02\uffff"+
            "\x01\x04\x0e\uffff\x01\x04\x01\uffff\x01\x04\x02\uffff\x01\x01"+
            "\x04\uffff\x06\x04\x01\uffff\x01\x04\x01\uffff\x05\x04\x0a\uffff"+
            "\x01\x04\x0e\uffff\x01\x03\x01\x02\x01\uffff\x0e\x03\x01\uffff"+
            "\x03\x03\x01\uffff\x01\x03\x02\uffff\x03\x03\x09\x04\x01\uffff"+
            "\x01\x03\x06\uffff\x02\x03\x10\uffff\x01\x03\x06\x04\x01\x03",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA107_eot = DFA.UnpackEncodedString(DFA107_eotS);
    static readonly short[] DFA107_eof = DFA.UnpackEncodedString(DFA107_eofS);
    static readonly char[] DFA107_min = DFA.UnpackEncodedStringToUnsignedChars(DFA107_minS);
    static readonly char[] DFA107_max = DFA.UnpackEncodedStringToUnsignedChars(DFA107_maxS);
    static readonly short[] DFA107_accept = DFA.UnpackEncodedString(DFA107_acceptS);
    static readonly short[] DFA107_special = DFA.UnpackEncodedString(DFA107_specialS);
    static readonly short[][] DFA107_transition = DFA.UnpackEncodedStringArray(DFA107_transitionS);

    protected class DFA107 : DFA
    {
        public DFA107(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 107;
            this.eot = DFA107_eot;
            this.eof = DFA107_eof;
            this.min = DFA107_min;
            this.max = DFA107_max;
            this.accept = DFA107_accept;
            this.special = DFA107_special;
            this.transition = DFA107_transition;

        }

        override public string Description
        {
            get { return "412:1: non_assignment_expression : ( ( anonymous_function_signature '=>' )=> lambda_expression | ( query_expression )=> query_expression | conditional_expression );"; }
        }

    }


    protected internal int DFA107_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA107_1 = input.LA(1);

                   	 
                   	int index107_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred21_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 4; }

                   	 
                   	input.Seek(index107_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA107_2 = input.LA(1);

                   	 
                   	int index107_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred21_cs()) ) { s = 23; }

                   	else if ( (synpred22_cs()) ) { s = 24; }

                   	else if ( (true) ) { s = 4; }

                   	 
                   	input.Seek(index107_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA107_3 = input.LA(1);

                   	 
                   	int index107_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred21_cs()) ) { s = 23; }

                   	else if ( (true) ) { s = 4; }

                   	 
                   	input.Seek(index107_3);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 107, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA230_eotS =
        "\x0f\uffff";
    const string DFA230_eofS =
        "\x0f\uffff";
    const string DFA230_minS =
        "\x01\x04\x05\uffff\x01\x04\x01\uffff\x01\x04\x06\uffff";
    const string DFA230_maxS =
        "\x01\u00ca\x05\uffff\x01\u00ca\x01\uffff\x01\u00ca\x06\uffff";
    const string DFA230_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\uffff\x01"+
        "\x07\x01\uffff\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x06\x01\x0c";
    const string DFA230_specialS =
        "\x0f\uffff}>";
    static readonly string[] DFA230_transitionS = {
            "\x01\x08\x0e\uffff\x01\x0a\x2d\uffff\x01\x08\x01\uffff\x01"+
            "\x03\x0d\uffff\x01\x01\x01\x06\x0e\uffff\x01\x0b\x22\uffff\x02"+
            "\x08\x01\uffff\x0e\x08\x01\x02\x03\x08\x01\uffff\x01\x08\x01"+
            "\x05\x01\uffff\x03\x08\x09\x07\x01\x09\x01\x08\x01\uffff\x01"+
            "\x04\x01\uffff\x02\x0c\x01\uffff\x02\x08\x10\uffff\x01\x08\x06"+
            "\x07\x01\x08",
            "",
            "",
            "",
            "",
            "",
            "\x0a\x0d\x33\uffff\x01\x0d\x22\uffff\x01\x07\x1f\uffff\x02"+
            "\x0d\x01\uffff\x0e\x0d\x01\uffff\x03\x0d\x01\uffff\x01\x0d\x02"+
            "\uffff\x0c\x0d\x01\uffff\x01\x0d\x06\uffff\x02\x0d\x10\uffff"+
            "\x08\x0d",
            "",
            "\x0b\x07\x32\uffff\x01\x07\x11\uffff\x02\x07\x01\uffff\x01"+
            "\x07\x01\uffff\x01\x0e\x0a\uffff\x03\x07\x1e\uffff\x02\x07\x01"+
            "\uffff\x0e\x07\x01\uffff\x03\x07\x01\uffff\x01\x07\x02\uffff"+
            "\x0c\x07\x01\uffff\x01\x07\x02\uffff\x01\x07\x03\uffff\x02\x07"+
            "\x10\uffff\x08\x07",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA230_eot = DFA.UnpackEncodedString(DFA230_eotS);
    static readonly short[] DFA230_eof = DFA.UnpackEncodedString(DFA230_eofS);
    static readonly char[] DFA230_min = DFA.UnpackEncodedStringToUnsignedChars(DFA230_minS);
    static readonly char[] DFA230_max = DFA.UnpackEncodedStringToUnsignedChars(DFA230_maxS);
    static readonly short[] DFA230_accept = DFA.UnpackEncodedString(DFA230_acceptS);
    static readonly short[] DFA230_special = DFA.UnpackEncodedString(DFA230_specialS);
    static readonly short[][] DFA230_transition = DFA.UnpackEncodedStringArray(DFA230_transitionS);

    protected class DFA230 : DFA
    {
        public DFA230(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 230;
            this.eot = DFA230_eot;
            this.eof = DFA230_eof;
            this.min = DFA230_min;
            this.max = DFA230_max;
            this.accept = DFA230_accept;
            this.special = DFA230_special;
            this.transition = DFA230_transition;

        }

        override public string Description
        {
            get { return "776:2: ( 'const' type constant_declarators ';' | event_declaration | 'partial' ( method_declaration | interface_declaration | class_declaration | struct_declaration ) | interface_declaration | class_declaration | 'void' method_declaration | type ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration ) | struct_declaration | enum_declaration | delegate_declaration | conversion_operator_declaration | constructor_declaration )"; }
        }

    }

    const string DFA229_eotS =
        "\x0a\uffff";
    const string DFA229_eofS =
        "\x0a\uffff";
    const string DFA229_minS =
        "\x01\x04\x03\x00\x06\uffff";
    const string DFA229_maxS =
        "\x01\u00ca\x03\x00\x06\uffff";
    const string DFA229_acceptS =
        "\x04\uffff\x01\x04\x01\x06\x01\x01\x01\x02\x01\x03\x01\x05";
    const string DFA229_specialS =
        "\x01\uffff\x01\x00\x01\x01\x01\x02\x06\uffff}>";
    static readonly string[] DFA229_transitionS = {
            "\x01\x02\x09\x03\x33\uffff\x01\x02\x11\uffff\x01\x04\x30\uffff"+
            "\x02\x02\x01\uffff\x0e\x02\x01\uffff\x03\x02\x01\uffff\x01\x02"+
            "\x02\uffff\x03\x02\x09\x01\x01\uffff\x01\x02\x02\uffff\x01\x05"+
            "\x03\uffff\x02\x02\x10\uffff\x01\x02\x06\x01\x01\x02",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA229_eot = DFA.UnpackEncodedString(DFA229_eotS);
    static readonly short[] DFA229_eof = DFA.UnpackEncodedString(DFA229_eofS);
    static readonly char[] DFA229_min = DFA.UnpackEncodedStringToUnsignedChars(DFA229_minS);
    static readonly char[] DFA229_max = DFA.UnpackEncodedStringToUnsignedChars(DFA229_maxS);
    static readonly short[] DFA229_accept = DFA.UnpackEncodedString(DFA229_acceptS);
    static readonly short[] DFA229_special = DFA.UnpackEncodedString(DFA229_specialS);
    static readonly short[][] DFA229_transition = DFA.UnpackEncodedStringArray(DFA229_transitionS);

    protected class DFA229 : DFA
    {
        public DFA229(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 229;
            this.eot = DFA229_eot;
            this.eof = DFA229_eof;
            this.min = DFA229_min;
            this.max = DFA229_max;
            this.accept = DFA229_accept;
            this.special = DFA229_special;
            this.transition = DFA229_transition;

        }

        override public string Description
        {
            get { return "786:9: ( ( member_name '(' )=> method_declaration | ( member_name '{' )=> property_declaration | ( member_name '.' 'this' )=> type_name '.' indexer_declaration | indexer_declaration | field_declaration | operator_declaration )"; }
        }

    }


    protected internal int DFA229_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA229_1 = input.LA(1);

                   	 
                   	int index229_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred28_cs()) ) { s = 6; }

                   	else if ( (synpred29_cs()) ) { s = 7; }

                   	 
                   	input.Seek(index229_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA229_2 = input.LA(1);

                   	 
                   	int index229_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred28_cs()) ) { s = 6; }

                   	else if ( (synpred29_cs()) ) { s = 7; }

                   	else if ( (synpred30_cs()) ) { s = 8; }

                   	else if ( (true) ) { s = 9; }

                   	 
                   	input.Seek(index229_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA229_3 = input.LA(1);

                   	 
                   	int index229_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred28_cs()) ) { s = 6; }

                   	else if ( (synpred29_cs()) ) { s = 7; }

                   	 
                   	input.Seek(index229_3);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 229, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA233_eotS =
        "\x10\uffff";
    const string DFA233_eofS =
        "\x10\uffff";
    const string DFA233_minS =
        "\x01\x11\x07\uffff\x01\x11\x07\uffff";
    const string DFA233_maxS =
        "\x01\x7f\x07\uffff\x01\x59\x07\uffff";
    const string DFA233_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06\x01"+
        "\x07\x01\uffff\x01\x09\x01\x0a\x01\x0c\x01\x0d\x01\x0e\x01\x08\x01"+
        "\x0b";
    const string DFA233_specialS =
        "\x10\uffff}>";
    static readonly string[] DFA233_transitionS = {
            "\x01\x08\x51\uffff\x01\x0b\x01\x01\x0f\uffff\x01\x0c\x01\x04"+
            "\x01\x02\x01\x03\x01\x07\x01\x0d\x02\uffff\x01\x09\x01\x0a\x01"+
            "\x06\x01\x05",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\x0e\x47\uffff\x01\x0f",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA233_eot = DFA.UnpackEncodedString(DFA233_eotS);
    static readonly short[] DFA233_eof = DFA.UnpackEncodedString(DFA233_eofS);
    static readonly char[] DFA233_min = DFA.UnpackEncodedStringToUnsignedChars(DFA233_minS);
    static readonly char[] DFA233_max = DFA.UnpackEncodedStringToUnsignedChars(DFA233_maxS);
    static readonly short[] DFA233_accept = DFA.UnpackEncodedString(DFA233_acceptS);
    static readonly short[] DFA233_special = DFA.UnpackEncodedString(DFA233_specialS);
    static readonly short[][] DFA233_transition = DFA.UnpackEncodedStringArray(DFA233_transitionS);

    protected class DFA233 : DFA
    {
        public DFA233(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 233;
            this.eot = DFA233_eot;
            this.eof = DFA233_eof;
            this.min = DFA233_min;
            this.max = DFA233_max;
            this.accept = DFA233_accept;
            this.special = DFA233_special;
            this.transition = DFA233_transition;

        }

        override public string Description
        {
            get { return "826:1: overloadable_binary_operator : ( '*' | '/' | '%' | '&' | '|' | '^' | '<<' | '>' '>' | '==' | '!=' | '>' | '<' | '>=' | '<=' );"; }
        }

    }

    const string DFA241_eotS =
        "\x2f\uffff";
    const string DFA241_eofS =
        "\x2f\uffff";
    const string DFA241_minS =
        "\x01\x04\x04\x00\x14\uffff\x01\x00\x13\uffff\x01\x00\x01\uffff";
    const string DFA241_maxS =
        "\x01\u00ca\x04\x00\x14\uffff\x01\x00\x13\uffff\x01\x00\x01\uffff";
    const string DFA241_acceptS =
        "\x05\uffff\x02\x01\x01\x03\x26\uffff\x01\x02";
    const string DFA241_specialS =
        "\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x14\uffff\x01\x05\x13"+
        "\uffff\x01\x06\x01\uffff}>";
    static readonly string[] DFA241_transitionS = {
            "\x01\x2d\x09\x07\x02\uffff\x01\x07\x01\uffff\x01\x07\x01\uffff"+
            "\x01\x07\x04\uffff\x01\x07\x24\uffff\x01\x07\x02\uffff\x01\x2d"+
            "\x02\uffff\x01\x07\x04\uffff\x01\x07\x07\uffff\x01\x06\x01\x05"+
            "\x01\x07\x01\uffff\x01\x07\x02\uffff\x01\x07\x04\uffff\x06\x07"+
            "\x01\uffff\x01\x07\x01\uffff\x05\x07\x0a\uffff\x01\x07\x0e\uffff"+
            "\x01\x2d\x01\x19\x01\uffff\x0e\x2d\x01\uffff\x03\x2d\x01\x07"+
            "\x01\x2d\x02\uffff\x03\x2d\x09\x03\x01\uffff\x01\x2d\x05\uffff"+
            "\x01\x07\x01\x01\x01\x02\x02\uffff\x01\x07\x01\uffff\x09\x07"+
            "\x02\uffff\x01\x07\x01\x04\x06\x03\x01\x2d",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\uffff",
            ""
    };

    static readonly short[] DFA241_eot = DFA.UnpackEncodedString(DFA241_eotS);
    static readonly short[] DFA241_eof = DFA.UnpackEncodedString(DFA241_eofS);
    static readonly char[] DFA241_min = DFA.UnpackEncodedStringToUnsignedChars(DFA241_minS);
    static readonly char[] DFA241_max = DFA.UnpackEncodedStringToUnsignedChars(DFA241_maxS);
    static readonly short[] DFA241_accept = DFA.UnpackEncodedString(DFA241_acceptS);
    static readonly short[] DFA241_special = DFA.UnpackEncodedString(DFA241_specialS);
    static readonly short[][] DFA241_transition = DFA.UnpackEncodedStringArray(DFA241_transitionS);

    protected class DFA241 : DFA
    {
        public DFA241(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 241;
            this.eot = DFA241_eot;
            this.eof = DFA241_eof;
            this.min = DFA241_min;
            this.max = DFA241_max;
            this.accept = DFA241_accept;
            this.special = DFA241_special;
            this.transition = DFA241_transition;

        }

        override public string Description
        {
            get { return "876:1: statement : ( ( declaration_statement )=> declaration_statement | ( identifier ':' )=> labeled_statement | embedded_statement );"; }
        }

    }


    protected internal int DFA241_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA241_0 = input.LA(1);

                   	 
                   	int index241_0 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA241_0 == 177) ) { s = 1; }

                   	else if ( (LA241_0 == 178) ) { s = 2; }

                   	else if ( ((LA241_0 >= 160 && LA241_0 <= 168) || (LA241_0 >= 196 && LA241_0 <= 201)) ) { s = 3; }

                   	else if ( (LA241_0 == 195) ) { s = 4; }

                   	else if ( (LA241_0 == 82) && (synpred33_cs()) ) { s = 5; }

                   	else if ( (LA241_0 == 81) && (synpred33_cs()) ) { s = 6; }

                   	else if ( ((LA241_0 >= Real_literal && LA241_0 <= NULL) || LA241_0 == MINUS || LA241_0 == USING || LA241_0 == IF || LA241_0 == SEMI || LA241_0 == 62 || LA241_0 == 68 || LA241_0 == 73 || LA241_0 == 83 || LA241_0 == 85 || LA241_0 == 88 || (LA241_0 >= 93 && LA241_0 <= 98) || LA241_0 == 100 || (LA241_0 >= 102 && LA241_0 <= 106) || LA241_0 == 117 || LA241_0 == 153 || LA241_0 == 176 || LA241_0 == 181 || (LA241_0 >= 183 && LA241_0 <= 191) || LA241_0 == 194) ) { s = 7; }

                   	else if ( (LA241_0 == 133) ) { s = 25; }

                   	else if ( (LA241_0 == IDENTIFIER || LA241_0 == 65 || LA241_0 == 132 || (LA241_0 >= 135 && LA241_0 <= 148) || (LA241_0 >= 150 && LA241_0 <= 152) || LA241_0 == 154 || (LA241_0 >= 157 && LA241_0 <= 159) || LA241_0 == 170 || LA241_0 == 202) ) { s = 45; }

                   	 
                   	input.Seek(index241_0);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA241_1 = input.LA(1);

                   	 
                   	int index241_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred33_cs()) ) { s = 6; }

                   	else if ( (synpred34_cs()) ) { s = 46; }

                   	else if ( (true) ) { s = 7; }

                   	 
                   	input.Seek(index241_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA241_2 = input.LA(1);

                   	 
                   	int index241_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred33_cs()) ) { s = 6; }

                   	else if ( (synpred34_cs()) ) { s = 46; }

                   	else if ( (true) ) { s = 7; }

                   	 
                   	input.Seek(index241_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA241_3 = input.LA(1);

                   	 
                   	int index241_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred33_cs()) ) { s = 6; }

                   	else if ( (true) ) { s = 7; }

                   	 
                   	input.Seek(index241_3);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA241_4 = input.LA(1);

                   	 
                   	int index241_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred33_cs()) ) { s = 6; }

                   	else if ( (synpred34_cs()) ) { s = 46; }

                   	else if ( (true) ) { s = 7; }

                   	 
                   	input.Seek(index241_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA241_25 = input.LA(1);

                   	 
                   	int index241_25 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred33_cs()) ) { s = 6; }

                   	else if ( (synpred34_cs()) ) { s = 46; }

                   	else if ( (true) ) { s = 7; }

                   	 
                   	input.Seek(index241_25);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 6 : 
                   	int LA241_45 = input.LA(1);

                   	 
                   	int index241_45 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred33_cs()) ) { s = 6; }

                   	else if ( (synpred34_cs()) ) { s = 46; }

                   	else if ( (true) ) { s = 7; }

                   	 
                   	input.Seek(index241_45);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 241, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA242_eotS =
        "\x11\uffff";
    const string DFA242_eofS =
        "\x11\uffff";
    const string DFA242_minS =
        "\x01\x04\x05\uffff\x02\x19\x02\uffff\x01\x0e\x06\uffff";
    const string DFA242_maxS =
        "\x01\u00ca\x05\uffff\x02\x58\x02\uffff\x01\u00bb\x06\uffff";
    const string DFA242_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x02\uffff\x01"+
        "\x08\x01\x09\x01\uffff\x01\x0b\x01\x0c\x01\x0d\x01\x06\x01\x07\x01"+
        "\x0a";
    const string DFA242_specialS =
        "\x11\uffff}>";
    static readonly string[] DFA242_transitionS = {
            "\x0a\x0d\x02\uffff\x01\x0d\x01\uffff\x01\x09\x01\uffff\x01"+
            "\x02\x04\uffff\x01\x01\x24\uffff\x01\x01\x02\uffff\x01\x0d\x02"+
            "\uffff\x01\x0d\x04\uffff\x01\x0b\x09\uffff\x01\x0d\x01\uffff"+
            "\x01\x0d\x02\uffff\x01\x0d\x04\uffff\x01\x0d\x01\x06\x01\x07"+
            "\x03\x0d\x01\uffff\x01\x0d\x01\uffff\x05\x0d\x0a\uffff\x01\x0d"+
            "\x0e\uffff\x02\x0d\x01\uffff\x0e\x0d\x01\uffff\x03\x0d\x01\x04"+
            "\x01\x0d\x02\uffff\x0c\x0d\x01\uffff\x01\x0d\x05\uffff\x01\x0c"+
            "\x02\x0d\x02\uffff\x01\x02\x01\uffff\x04\x03\x04\x04\x01\x05"+
            "\x02\uffff\x01\x08\x01\x0a\x07\x0d",
            "",
            "",
            "",
            "",
            "",
            "\x01\x0e\x24\uffff\x01\x0e\x19\uffff\x01\x0d",
            "\x01\x0f\x24\uffff\x01\x0f\x19\uffff\x01\x0d",
            "",
            "",
            "\x04\x0d\x07\uffff\x01\x0d\x28\uffff\x01\x0d\x11\uffff\x01"+
            "\x0d\x01\uffff\x01\x0d\x01\uffff\x02\x0d\x09\uffff\x06\x0d\x02"+
            "\uffff\x19\x0d\x15\uffff\x01\x10\x21\uffff\x01\x10",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA242_eot = DFA.UnpackEncodedString(DFA242_eotS);
    static readonly short[] DFA242_eof = DFA.UnpackEncodedString(DFA242_eofS);
    static readonly char[] DFA242_min = DFA.UnpackEncodedStringToUnsignedChars(DFA242_minS);
    static readonly char[] DFA242_max = DFA.UnpackEncodedStringToUnsignedChars(DFA242_maxS);
    static readonly short[] DFA242_accept = DFA.UnpackEncodedString(DFA242_acceptS);
    static readonly short[] DFA242_special = DFA.UnpackEncodedString(DFA242_specialS);
    static readonly short[][] DFA242_transition = DFA.UnpackEncodedStringArray(DFA242_transitionS);

    protected class DFA242 : DFA
    {
        public DFA242(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 242;
            this.eot = DFA242_eot;
            this.eof = DFA242_eof;
            this.min = DFA242_min;
            this.max = DFA242_max;
            this.accept = DFA242_accept;
            this.special = DFA242_special;
            this.transition = DFA242_transition;

        }

        override public string Description
        {
            get { return "881:1: embedded_statement : ( block | selection_statement | iteration_statement | jump_statement | try_statement | checked_statement | unchecked_statement | lock_statement | using_statement | yield_statement | unsafe_statement | fixed_statement | expression_statement );"; }
        }

    }

    const string DFA259_eotS =
        "\x1a\uffff";
    const string DFA259_eofS =
        "\x1a\uffff";
    const string DFA259_minS =
        "\x01\x04\x04\x00\x14\uffff\x01\x00";
    const string DFA259_maxS =
        "\x01\u00ca\x04\x00\x14\uffff\x01\x00";
    const string DFA259_acceptS =
        "\x05\uffff\x01\x01\x01\x02\x13\uffff";
    const string DFA259_specialS =
        "\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x14\uffff\x01\x05}>";
    static readonly string[] DFA259_transitionS = {
            "\x01\x19\x09\x06\x02\uffff\x01\x06\x30\uffff\x01\x19\x02\uffff"+
            "\x01\x06\x0d\uffff\x01\x05\x01\x06\x01\uffff\x01\x06\x02\uffff"+
            "\x01\x06\x04\uffff\x06\x06\x01\uffff\x01\x06\x01\uffff\x05\x06"+
            "\x0a\uffff\x01\x06\x0e\uffff\x01\x19\x01\x04\x01\uffff\x0e\x19"+
            "\x01\uffff\x03\x19\x01\uffff\x01\x19\x02\uffff\x03\x19\x09\x03"+
            "\x01\uffff\x01\x19\x06\uffff\x01\x01\x01\x02\x10\uffff\x01\x19"+
            "\x06\x03\x01\x19",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\uffff"
    };

    static readonly short[] DFA259_eot = DFA.UnpackEncodedString(DFA259_eotS);
    static readonly short[] DFA259_eof = DFA.UnpackEncodedString(DFA259_eofS);
    static readonly char[] DFA259_min = DFA.UnpackEncodedStringToUnsignedChars(DFA259_minS);
    static readonly char[] DFA259_max = DFA.UnpackEncodedStringToUnsignedChars(DFA259_maxS);
    static readonly short[] DFA259_accept = DFA.UnpackEncodedString(DFA259_acceptS);
    static readonly short[] DFA259_special = DFA.UnpackEncodedString(DFA259_specialS);
    static readonly short[][] DFA259_transition = DFA.UnpackEncodedStringArray(DFA259_transitionS);

    protected class DFA259 : DFA
    {
        public DFA259(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 259;
            this.eot = DFA259_eot;
            this.eof = DFA259_eof;
            this.min = DFA259_min;
            this.max = DFA259_max;
            this.accept = DFA259_accept;
            this.special = DFA259_special;
            this.transition = DFA259_transition;

        }

        override public string Description
        {
            get { return "970:1: for_initializer : ( ( local_variable_declaration )=> local_variable_declaration | statement_expression_list );"; }
        }

    }


    protected internal int DFA259_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA259_0 = input.LA(1);

                   	 
                   	int index259_0 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA259_0 == 177) ) { s = 1; }

                   	else if ( (LA259_0 == 178) ) { s = 2; }

                   	else if ( ((LA259_0 >= 160 && LA259_0 <= 168) || (LA259_0 >= 196 && LA259_0 <= 201)) ) { s = 3; }

                   	else if ( (LA259_0 == 133) ) { s = 4; }

                   	else if ( (LA259_0 == 82) && (synpred38_cs()) ) { s = 5; }

                   	else if ( ((LA259_0 >= Real_literal && LA259_0 <= NULL) || LA259_0 == MINUS || LA259_0 == 68 || LA259_0 == 83 || LA259_0 == 85 || LA259_0 == 88 || (LA259_0 >= 93 && LA259_0 <= 98) || LA259_0 == 100 || (LA259_0 >= 102 && LA259_0 <= 106) || LA259_0 == 117) ) { s = 6; }

                   	else if ( (LA259_0 == IDENTIFIER || LA259_0 == 65 || LA259_0 == 132 || (LA259_0 >= 135 && LA259_0 <= 148) || (LA259_0 >= 150 && LA259_0 <= 152) || LA259_0 == 154 || (LA259_0 >= 157 && LA259_0 <= 159) || LA259_0 == 170 || LA259_0 == 195 || LA259_0 == 202) ) { s = 25; }

                   	 
                   	input.Seek(index259_0);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA259_1 = input.LA(1);

                   	 
                   	int index259_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred38_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index259_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA259_2 = input.LA(1);

                   	 
                   	int index259_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred38_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index259_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA259_3 = input.LA(1);

                   	 
                   	int index259_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred38_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index259_3);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA259_4 = input.LA(1);

                   	 
                   	int index259_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred38_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index259_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA259_25 = input.LA(1);

                   	 
                   	int index259_25 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred38_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index259_25);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 259, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
    const string DFA271_eotS =
        "\x1a\uffff";
    const string DFA271_eofS =
        "\x1a\uffff";
    const string DFA271_minS =
        "\x01\x04\x04\x00\x14\uffff\x01\x00";
    const string DFA271_maxS =
        "\x01\u00ca\x04\x00\x14\uffff\x01\x00";
    const string DFA271_acceptS =
        "\x05\uffff\x01\x01\x01\x02\x13\uffff";
    const string DFA271_specialS =
        "\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x14\uffff\x01\x05}>";
    static readonly string[] DFA271_transitionS = {
            "\x01\x19\x09\x06\x02\uffff\x01\x06\x30\uffff\x01\x19\x02\uffff"+
            "\x01\x06\x0d\uffff\x01\x05\x01\x06\x01\uffff\x01\x06\x02\uffff"+
            "\x01\x06\x04\uffff\x06\x06\x01\uffff\x01\x06\x01\uffff\x05\x06"+
            "\x0a\uffff\x01\x06\x0e\uffff\x01\x19\x01\x04\x01\uffff\x0e\x19"+
            "\x01\uffff\x03\x19\x01\uffff\x01\x19\x02\uffff\x03\x19\x09\x03"+
            "\x01\uffff\x01\x19\x06\uffff\x01\x01\x01\x02\x10\uffff\x01\x19"+
            "\x06\x03\x01\x19",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\x01\uffff"
    };

    static readonly short[] DFA271_eot = DFA.UnpackEncodedString(DFA271_eotS);
    static readonly short[] DFA271_eof = DFA.UnpackEncodedString(DFA271_eofS);
    static readonly char[] DFA271_min = DFA.UnpackEncodedStringToUnsignedChars(DFA271_minS);
    static readonly char[] DFA271_max = DFA.UnpackEncodedStringToUnsignedChars(DFA271_maxS);
    static readonly short[] DFA271_accept = DFA.UnpackEncodedString(DFA271_acceptS);
    static readonly short[] DFA271_special = DFA.UnpackEncodedString(DFA271_specialS);
    static readonly short[][] DFA271_transition = DFA.UnpackEncodedStringArray(DFA271_transitionS);

    protected class DFA271 : DFA
    {
        public DFA271(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 271;
            this.eot = DFA271_eot;
            this.eof = DFA271_eof;
            this.min = DFA271_min;
            this.max = DFA271_max;
            this.accept = DFA271_accept;
            this.special = DFA271_special;
            this.transition = DFA271_transition;

        }

        override public string Description
        {
            get { return "1022:1: resource_acquisition : ( ( local_variable_declaration )=> local_variable_declaration | expression );"; }
        }

    }


    protected internal int DFA271_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA271_0 = input.LA(1);

                   	 
                   	int index271_0 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (LA271_0 == 177) ) { s = 1; }

                   	else if ( (LA271_0 == 178) ) { s = 2; }

                   	else if ( ((LA271_0 >= 160 && LA271_0 <= 168) || (LA271_0 >= 196 && LA271_0 <= 201)) ) { s = 3; }

                   	else if ( (LA271_0 == 133) ) { s = 4; }

                   	else if ( (LA271_0 == 82) && (synpred39_cs()) ) { s = 5; }

                   	else if ( ((LA271_0 >= Real_literal && LA271_0 <= NULL) || LA271_0 == MINUS || LA271_0 == 68 || LA271_0 == 83 || LA271_0 == 85 || LA271_0 == 88 || (LA271_0 >= 93 && LA271_0 <= 98) || LA271_0 == 100 || (LA271_0 >= 102 && LA271_0 <= 106) || LA271_0 == 117) ) { s = 6; }

                   	else if ( (LA271_0 == IDENTIFIER || LA271_0 == 65 || LA271_0 == 132 || (LA271_0 >= 135 && LA271_0 <= 148) || (LA271_0 >= 150 && LA271_0 <= 152) || LA271_0 == 154 || (LA271_0 >= 157 && LA271_0 <= 159) || LA271_0 == 170 || LA271_0 == 195 || LA271_0 == 202) ) { s = 25; }

                   	 
                   	input.Seek(index271_0);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA271_1 = input.LA(1);

                   	 
                   	int index271_1 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred39_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index271_1);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA271_2 = input.LA(1);

                   	 
                   	int index271_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred39_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index271_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA271_3 = input.LA(1);

                   	 
                   	int index271_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred39_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index271_3);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA271_4 = input.LA(1);

                   	 
                   	int index271_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred39_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index271_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA271_25 = input.LA(1);

                   	 
                   	int index271_25 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred39_cs()) ) { s = 5; }

                   	else if ( (true) ) { s = 6; }

                   	 
                   	input.Seek(index271_25);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae =
            new NoViableAltException(dfa.Description, 271, _s, input);
        dfa.Error(nvae);
        throw nvae;
    }
 

    public static readonly BitSet FOLLOW_namespace_body_in_compilation_unit88 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_61_in_namespace_declaration97 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_qualified_identifier_in_namespace_declaration101 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_namespace_block_in_namespace_declaration105 = new BitSet(new ulong[]{0x0000000002000002UL});
    public static readonly BitSet FOLLOW_SEMI_in_namespace_declaration109 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_namespace_block118 = new BitSet(new ulong[]{0xA0000000000C0000UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_namespace_body_in_namespace_block122 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_namespace_block127 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_extern_alias_directives_in_namespace_body136 = new BitSet(new ulong[]{0x20000000000C0002UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_using_directives_in_namespace_body141 = new BitSet(new ulong[]{0x2000000000080002UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_global_attributes_in_namespace_body146 = new BitSet(new ulong[]{0x2000000000080002UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_namespace_member_declarations_in_namespace_body151 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_extern_alias_directive_in_extern_alias_directives160 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_64_in_extern_alias_directive169 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_65_in_extern_alias_directive173 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_extern_alias_directive177 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_extern_alias_directive180 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_using_directive_in_using_directives188 = new BitSet(new ulong[]{0x0000000000040002UL});
    public static readonly BitSet FOLLOW_using_alias_directive_in_using_directive198 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_using_namespace_directive_in_using_directive203 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_USING_in_using_alias_directive212 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_using_alias_directive216 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_using_alias_directive220 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_namespace_or_type_name_in_using_alias_directive224 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_using_alias_directive228 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_USING_in_using_namespace_directive236 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_namespace_name_in_using_namespace_directive240 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_using_namespace_directive244 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_namespace_member_declaration_in_namespace_member_declarations252 = new BitSet(new ulong[]{0x2000000000080002UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_namespace_declaration_in_namespace_member_declaration261 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attributes_in_namespace_member_declaration266 = new BitSet(new ulong[]{0x2000000000080000UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_modifiers_in_namespace_member_declaration271 = new BitSet(new ulong[]{0x2000000000080000UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_type_declaration_in_namespace_member_declaration276 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_67_in_type_declaration290 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_class_declaration_in_type_declaration295 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_declaration_in_type_declaration307 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_declaration_in_type_declaration319 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_class_declaration_in_type_declaration325 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_declaration_in_type_declaration330 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_declaration_in_type_declaration335 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_enum_declaration_in_type_declaration340 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_delegate_declaration_in_type_declaration345 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_qualified_identifier354 = new BitSet(new ulong[]{0x0000000000004002UL});
    public static readonly BitSet FOLLOW_DOT_in_qualified_identifier357 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_qualified_identifier359 = new BitSet(new ulong[]{0x0000000000004002UL});
    public static readonly BitSet FOLLOW_namespace_or_type_name_in_namespace_name370 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_modifier_in_modifiers379 = new BitSet(new ulong[]{0x0000000000000002UL,0x000000000001FFF1UL});
    public static readonly BitSet FOLLOW_set_in_modifier0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attributes_in_class_member_declaration451 = new BitSet(new ulong[]{0x2000000000080010UL,0x000004020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_modifiers_in_class_member_declaration457 = new BitSet(new ulong[]{0x2000000000080010UL,0x000004020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_81_in_class_member_declaration463 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_class_member_declaration467 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_constant_declarators_in_class_member_declaration471 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_class_member_declaration475 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_event_declaration_in_class_member_declaration480 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_67_in_class_member_declaration487 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000617FFEDDFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_method_declaration_in_class_member_declaration490 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_declaration_in_class_member_declaration501 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_class_declaration_in_class_member_declaration512 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_declaration_in_class_member_declaration523 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_declaration_in_class_member_declaration529 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_82_in_class_member_declaration535 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_method_declaration_in_class_member_declaration539 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_class_member_declaration544 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000080002UL,0x000625FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_method_declaration_in_class_member_declaration558 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_property_declaration_in_class_member_declaration577 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_name_in_class_member_declaration600 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_DOT_in_class_member_declaration602 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000080000UL});
    public static readonly BitSet FOLLOW_indexer_declaration_in_class_member_declaration604 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_indexer_declaration_in_class_member_declaration613 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_field_declaration_in_class_member_declaration626 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_operator_declaration_in_class_member_declaration644 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_class_declaration_in_class_member_declaration662 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_declaration_in_class_member_declaration669 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_enum_declaration_in_class_member_declaration675 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_delegate_declaration_in_class_member_declaration682 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conversion_operator_declaration_in_class_member_declaration688 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constructor_declaration_in_class_member_declaration693 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_destructor_declaration_in_class_member_declaration699 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_83_in_primary_expression725 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_brackets_in_primary_expression729 = new BitSet(new ulong[]{0x000000000000C002UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_primary_expression_part_in_primary_expression733 = new BitSet(new ulong[]{0x000000000000C002UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_83_in_primary_expression749 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_brackets_in_primary_expression753 = new BitSet(new ulong[]{0x000000000000C002UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_primary_expression_part_in_primary_expression757 = new BitSet(new ulong[]{0x000000000000C002UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_primary_expression_start_in_primary_expression763 = new BitSet(new ulong[]{0x000000000000C002UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_primary_expression_part_in_primary_expression767 = new BitSet(new ulong[]{0x000000000000C002UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_68_in_primary_expression773 = new BitSet(new ulong[]{0x4000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_object_creation_expression_in_primary_expression801 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_primary_expression_part_in_primary_expression805 = new BitSet(new ulong[]{0x000000000000C002UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_delegate_creation_expression_in_primary_expression833 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_object_creation_expression_in_primary_expression841 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anonymous_object_creation_expression_in_primary_expression849 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_sizeof_expression_in_primary_expression862 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_checked_expression_in_primary_expression873 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unchecked_expression_in_primary_expression892 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_default_value_expression_in_primary_expression909 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anonymous_method_expression_in_primary_expression922 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_predefined_type_in_primary_expression_start935 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_primary_expression_start963 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_generic_argument_list_in_primary_expression_start967 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_primary_expression_start972 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000100000UL});
    public static readonly BitSet FOLLOW_84_in_primary_expression_start975 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_primary_expression_start979 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_83_in_primary_expression_start986 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_85_in_primary_expression_start992 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_paren_expression_in_primary_expression_start997 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeof_expression_in_primary_expression_start1002 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_literal_in_primary_expression_start1020 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_access_identifier_in_primary_expression_part1031 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_brackets_or_arguments_in_primary_expression_part1036 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_access_operator_in_access_identifier1044 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_type_or_generic_in_access_identifier1048 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_access_operator0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_brackets_in_brackets_or_arguments1070 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_arguments_in_brackets_or_arguments1074 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_86_in_brackets1082 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1A80012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_list_in_brackets1086 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_brackets1091 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_88_in_paren_expression1101 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_paren_expression1105 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_paren_expression1109 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_88_in_arguments1118 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7F9280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_argument_list_in_arguments1122 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_arguments1127 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_argument_in_argument_list1136 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_argument_list1139 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7F9280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_argument_in_argument_list1141 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_argument_name_in_argument1151 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7F9280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_argument_value_in_argument1155 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_argument_value_in_argument1160 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_argument_name1167 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_argument_name1171 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_argument_value1179 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ref_variable_reference_in_argument_value1185 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_91_in_argument_value1191 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_variable_reference_in_argument_value1195 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_92_in_ref_variable_reference1203 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_88_in_ref_variable_reference1225 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_ref_variable_reference1229 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_ref_variable_reference1233 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7F1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_ref_variable_reference_in_ref_variable_reference1238 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_reference_in_ref_variable_reference1242 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_reference_in_ref_variable_reference1278 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_variable_reference1288 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_rank_specifier_in_rank_specifiers1296 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_86_in_rank_specifier1314 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000002800000UL});
    public static readonly BitSet FOLLOW_dim_separators_in_rank_specifier1318 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_rank_specifier1323 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_89_in_dim_separators1332 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_type_name_in_delegate_creation_expression1345 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_delegate_creation_expression1349 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_name_in_delegate_creation_expression1353 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_delegate_creation_expression1357 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anonymous_object_initializer_in_anonymous_object_creation_expression1368 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_anonymous_object_initializer1377 = new BitSet(new ulong[]{0x8000000000000010UL,0x0000000002000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_member_declarator_list_in_anonymous_object_initializer1381 = new BitSet(new ulong[]{0x8000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_anonymous_object_initializer1386 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_anonymous_object_initializer1391 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_declarator_in_member_declarator_list1399 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_member_declarator_list1403 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_member_declarator_in_member_declarator_list1405 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_identifier_in_member_declarator1417 = new BitSet(new ulong[]{0x0000000000004000UL,0x0000000800000004UL});
    public static readonly BitSet FOLLOW_generic_argument_list_in_member_declarator1422 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DOT_in_member_declarator1432 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x00000007E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_primary_or_array_creation_expression_in_member_declarator1436 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_66_in_member_declarator1446 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_member_declarator1450 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_array_creation_expression_in_primary_or_array_creation_expression1465 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_expression_in_primary_or_array_creation_expression1470 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_68_in_array_creation_expression1481 = new BitSet(new ulong[]{0x4000000000000010UL,0x0000000000440002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_array_creation_expression1489 = new BitSet(new ulong[]{0x4000000000000010UL,0x0000000000440002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_86_in_array_creation_expression1494 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_list_in_array_creation_expression1498 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_array_creation_expression1502 = new BitSet(new ulong[]{0x400000000000C012UL,0x0000000001440002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_rank_specifiers_in_array_creation_expression1514 = new BitSet(new ulong[]{0x4000000000000012UL,0x0000000000440002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_array_initializer_in_array_creation_expression1519 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_arguments_in_array_creation_expression1555 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_invocation_part_in_array_creation_expression1559 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_invocation_part_in_array_creation_expression1571 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_arguments_in_array_creation_expression1577 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_array_initializer_in_array_creation_expression1599 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_rank_specifier_in_array_creation_expression1613 = new BitSet(new ulong[]{0x4000000000000010UL,0x0000000000440002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_array_initializer_in_array_creation_expression1622 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_array_initializer1643 = new BitSet(new ulong[]{0xC000000000013FF0UL,0x002007D7E36C0012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_variable_initializer_list_in_array_initializer1647 = new BitSet(new ulong[]{0x8000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_array_initializer1652 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_array_initializer1657 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_initializer_in_variable_initializer_list1665 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_variable_initializer_list1668 = new BitSet(new ulong[]{0x4000000000013FF0UL,0x002007D7E16C0012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_variable_initializer_in_variable_initializer_list1670 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_expression_in_variable_initializer1680 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_array_initializer_in_variable_initializer1684 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_93_in_sizeof_expression1692 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_sizeof_expression1696 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unmanaged_type_in_sizeof_expression1700 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_sizeof_expression1704 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_94_in_checked_expression1712 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_checked_expression1716 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_checked_expression1720 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_checked_expression1724 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_95_in_unchecked_expression1733 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_unchecked_expression1737 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_unchecked_expression1741 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_unchecked_expression1745 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_96_in_default_value_expression1754 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_default_value_expression1758 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_default_value_expression1762 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_default_value_expression1766 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_97_in_anonymous_method_expression1774 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_explicit_anonymous_function_signature_in_anonymous_method_expression1778 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_anonymous_method_expression1783 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_88_in_explicit_anonymous_function_signature1790 = new BitSet(new ulong[]{0x0000000004000010UL,0x0000000018040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_explicit_anonymous_function_parameter_list_in_explicit_anonymous_function_signature1794 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_explicit_anonymous_function_signature1799 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1807 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_explicit_anonymous_function_parameter_list1812 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000018040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_explicit_anonymous_function_parameter_in_explicit_anonymous_function_parameter_list1816 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_anonymous_function_parameter_modifier_in_explicit_anonymous_function_parameter1827 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_explicit_anonymous_function_parameter1832 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_explicit_anonymous_function_parameter1836 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_anonymous_function_parameter_modifier0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_object_creation_expression1860 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_object_creation_expression1869 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7F9280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_argument_list_in_object_creation_expression1873 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_object_creation_expression1878 = new BitSet(new ulong[]{0x4000000000000002UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_object_or_collection_initializer_in_object_creation_expression1882 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_object_or_collection_initializer_in_object_creation_expression1893 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_object_or_collection_initializer1905 = new BitSet(new ulong[]{0xC000000000013FF0UL,0x002007D7E3280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_object_initializer_in_object_or_collection_initializer1909 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_collection_initializer_in_object_or_collection_initializer1916 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_element_initializer_list_in_collection_initializer1926 = new BitSet(new ulong[]{0x8000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_collection_initializer1930 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_collection_initializer1935 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_element_initializer_in_element_initializer_list1944 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_element_initializer_list1948 = new BitSet(new ulong[]{0xC000000000013FF0UL,0x002007D7E3280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_element_initializer_in_element_initializer_list1950 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_non_assignment_expression_in_element_initializer1961 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_element_initializer1967 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_list_in_element_initializer1971 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_element_initializer1975 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_initializer_list_in_object_initializer1990 = new BitSet(new ulong[]{0x8000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_object_initializer1995 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_object_initializer2000 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_initializer_in_member_initializer_list2009 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_member_initializer_list2013 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_member_initializer_in_member_initializer_list2015 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_member_initializer2025 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_member_initializer2029 = new BitSet(new ulong[]{0x4000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_initializer_value_in_member_initializer2033 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_initializer_value2042 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_object_or_collection_initializer_in_initializer_value2048 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_98_in_typeof_expression2060 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_typeof_expression2064 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unbound_type_name_in_typeof_expression2075 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_type_in_typeof_expression2086 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_82_in_typeof_expression2098 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_typeof_expression2103 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unbound_type_name_start_in_unbound_type_name2118 = new BitSet(new ulong[]{0x0000000000004000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_generic_dimension_specifier_in_unbound_type_name2137 = new BitSet(new ulong[]{0x0000000000004000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_unbound_type_name_part_in_unbound_type_name2141 = new BitSet(new ulong[]{0x0000000000004000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_unbound_type_name_part_in_unbound_type_name2148 = new BitSet(new ulong[]{0x0000000000004000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_generic_dimension_specifier_in_unbound_type_name2158 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_unbound_type_name_start2168 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000100000UL});
    public static readonly BitSet FOLLOW_84_in_unbound_type_name_start2171 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_unbound_type_name_start2173 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DOT_in_unbound_type_name_part2182 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_unbound_type_name_part2186 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_99_in_generic_dimension_specifier2194 = new BitSet(new ulong[]{0x0000000000020000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_commas_in_generic_dimension_specifier2198 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_GT_in_generic_dimension_specifier2203 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_89_in_commas2212 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_namespace_or_type_name_in_type_name2228 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_or_generic_in_namespace_or_type_name2237 = new BitSet(new ulong[]{0x0000000000004002UL,0x0000000000100000UL});
    public static readonly BitSet FOLLOW_84_in_namespace_or_type_name2242 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_type_or_generic_in_namespace_or_type_name2244 = new BitSet(new ulong[]{0x0000000000004002UL});
    public static readonly BitSet FOLLOW_DOT_in_namespace_or_type_name2249 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_type_or_generic_in_namespace_or_type_name2253 = new BitSet(new ulong[]{0x0000000000004002UL});
    public static readonly BitSet FOLLOW_identifier_in_type_or_generic2273 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_generic_argument_list_in_type_or_generic2277 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_type_or_generic2282 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_qid_start_in_qid2293 = new BitSet(new ulong[]{0x000000000000C002UL});
    public static readonly BitSet FOLLOW_qid_part_in_qid2297 = new BitSet(new ulong[]{0x000000000000C002UL});
    public static readonly BitSet FOLLOW_predefined_type_in_qid_start2307 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_qid_start2323 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_generic_argument_list_in_qid_start2327 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_qid_start2334 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000100000UL});
    public static readonly BitSet FOLLOW_84_in_qid_start2339 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_qid_start2343 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_literal_in_qid_start2350 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_access_identifier_in_qid_part2364 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_99_in_generic_argument_list2374 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_arguments_in_generic_argument_list2378 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_GT_in_generic_argument_list2382 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_type_arguments2391 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_type_arguments2394 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_type_arguments2396 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_predefined_type_in_type2425 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_type_name_in_type2429 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_rank_specifiers_in_type2434 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_100_in_type2438 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_predefined_type_in_type2467 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000003000000000UL});
    public static readonly BitSet FOLLOW_type_name_in_type2471 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000003000000000UL});
    public static readonly BitSet FOLLOW_100_in_type2477 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_101_in_type2482 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_predefined_type_in_type2489 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_name_in_type2493 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_82_in_type2499 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_100_in_type2501 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_predefined_type_in_non_nullable_type2512 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000400000UL});
    public static readonly BitSet FOLLOW_type_name_in_non_nullable_type2516 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000400000UL});
    public static readonly BitSet FOLLOW_rank_specifiers_in_non_nullable_type2525 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_100_in_non_nullable_type2529 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_100_in_non_nullable_type2538 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_82_in_non_nullable_type2550 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_100_in_non_nullable_type2554 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_type_in_non_array_type2565 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_array_type2572 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_unmanaged_type2579 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_class_type2586 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_pointer_type2593 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SEMI_in_block2605 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_block2610 = new BitSet(new ulong[]{0xC000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_statement_list_in_block2614 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_block2619 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_statement_in_statement_list2626 = new BitSet(new ulong[]{0x4000000002153FF2UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_assignment_in_expression2651 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_non_assignment_expression_in_expression2657 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_expression_list2666 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_expression_list2670 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_expression_list2674 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_unary_expression_in_assignment2684 = new BitSet(new ulong[]{0x0000000000020000UL,0x000FF80000000004UL});
    public static readonly BitSet FOLLOW_assignment_operator_in_assignment2688 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_assignment2692 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_cast_expression_in_unary_expression2709 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primary_or_array_creation_expression_in_unary_expression2714 = new BitSet(new ulong[]{0x0000000000000002UL,0x000000C000000000UL});
    public static readonly BitSet FOLLOW_102_in_unary_expression2718 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000008000000000UL});
    public static readonly BitSet FOLLOW_103_in_unary_expression2723 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_104_in_unary_expression2729 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression2733 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MINUS_in_unary_expression2739 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression2743 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_105_in_unary_expression2749 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression2753 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_106_in_unary_expression2759 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression2763 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_pre_increment_expression_in_unary_expression2769 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_pre_decrement_expression_in_unary_expression2775 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_pointer_indirection_expression_in_unary_expression2781 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_addressof_expression_in_unary_expression2786 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_88_in_cast_expression2796 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_cast_expression2800 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_cast_expression2804 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_cast_expression2808 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_66_in_assignment_operator2816 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_107_in_assignment_operator2820 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_108_in_assignment_operator2824 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_109_in_assignment_operator2828 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_110_in_assignment_operator2832 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_111_in_assignment_operator2836 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_112_in_assignment_operator2840 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_113_in_assignment_operator2844 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_114_in_assignment_operator2848 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_115_in_assignment_operator2852 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_GT_in_assignment_operator2856 = new BitSet(new ulong[]{0x0000000000000000UL,0x0010000000000000UL});
    public static readonly BitSet FOLLOW_116_in_assignment_operator2858 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_102_in_pre_increment_expression2867 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_pre_increment_expression2871 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_103_in_pre_decrement_expression2880 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_pre_decrement_expression2884 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_100_in_pointer_indirection_expression2892 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_pointer_indirection_expression2896 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_117_in_addressof_expression2904 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_addressof_expression2908 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lambda_expression_in_non_assignment_expression2929 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_query_expression_in_non_assignment_expression2940 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conditional_expression_in_non_assignment_expression2946 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_expression_in_multiplicative_expression2960 = new BitSet(new ulong[]{0x0000000000000002UL,0x00C0001000000000UL});
    public static readonly BitSet FOLLOW_set_in_multiplicative_expression2965 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_multiplicative_expression2975 = new BitSet(new ulong[]{0x0000000000000002UL,0x00C0001000000000UL});
    public static readonly BitSet FOLLOW_multiplicative_expression_in_additive_expression2985 = new BitSet(new ulong[]{0x0000000000010002UL,0x0000010000000000UL});
    public static readonly BitSet FOLLOW_set_in_additive_expression2988 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_multiplicative_expression_in_additive_expression2996 = new BitSet(new ulong[]{0x0000000000010002UL,0x0000010000000000UL});
    public static readonly BitSet FOLLOW_additive_expression_in_shift_expression3007 = new BitSet(new ulong[]{0x0000000000020002UL,0x0100000000000000UL});
    public static readonly BitSet FOLLOW_120_in_shift_expression3011 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_GT_in_shift_expression3013 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_GT_in_shift_expression3015 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_additive_expression_in_shift_expression3018 = new BitSet(new ulong[]{0x0000000000020002UL,0x0100000000000000UL});
    public static readonly BitSet FOLLOW_shift_expression_in_relational_expression3028 = new BitSet(new ulong[]{0x0000000000020002UL,0x0E10000800000000UL});
    public static readonly BitSet FOLLOW_set_in_relational_expression3035 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_shift_expression_in_relational_expression3045 = new BitSet(new ulong[]{0x0000000000020002UL,0x0E10000800000000UL});
    public static readonly BitSet FOLLOW_set_in_relational_expression3054 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_non_nullable_type_in_relational_expression3062 = new BitSet(new ulong[]{0x0000000000020002UL,0x0E10000800000000UL});
    public static readonly BitSet FOLLOW_relational_expression_in_equality_expression3076 = new BitSet(new ulong[]{0x0000000000000002UL,0x3000000000000000UL});
    public static readonly BitSet FOLLOW_set_in_equality_expression3083 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_relational_expression_in_equality_expression3091 = new BitSet(new ulong[]{0x0000000000000002UL,0x3000000000000000UL});
    public static readonly BitSet FOLLOW_equality_expression_in_and_expression3101 = new BitSet(new ulong[]{0x0000000000000002UL,0x0020000000000000UL});
    public static readonly BitSet FOLLOW_117_in_and_expression3104 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_equality_expression_in_and_expression3108 = new BitSet(new ulong[]{0x0000000000000002UL,0x0020000000000000UL});
    public static readonly BitSet FOLLOW_and_expression_in_exclusive_or_expression3118 = new BitSet(new ulong[]{0x0000000000000002UL,0x4000000000000000UL});
    public static readonly BitSet FOLLOW_126_in_exclusive_or_expression3121 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_and_expression_in_exclusive_or_expression3125 = new BitSet(new ulong[]{0x0000000000000002UL,0x4000000000000000UL});
    public static readonly BitSet FOLLOW_exclusive_or_expression_in_inclusive_or_expression3135 = new BitSet(new ulong[]{0x0000000000000002UL,0x8000000000000000UL});
    public static readonly BitSet FOLLOW_127_in_inclusive_or_expression3140 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_exclusive_or_expression_in_inclusive_or_expression3144 = new BitSet(new ulong[]{0x0000000000000002UL,0x8000000000000000UL});
    public static readonly BitSet FOLLOW_inclusive_or_expression_in_conditional_and_expression3154 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_128_in_conditional_and_expression3159 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_inclusive_or_expression_in_conditional_and_expression3163 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_conditional_and_expression_in_conditional_or_expression3173 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_129_in_conditional_or_expression3177 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_conditional_and_expression_in_conditional_or_expression3181 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conditional_or_expression_in_null_coalescing_expression3192 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_130_in_null_coalescing_expression3197 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_conditional_or_expression_in_null_coalescing_expression3201 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_null_coalescing_expression_in_conditional_expression3211 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000002000000000UL});
    public static readonly BitSet FOLLOW_101_in_conditional_expression3216 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_conditional_expression3220 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_conditional_expression3224 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_conditional_expression3228 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anonymous_function_signature_in_lambda_expression3248 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_131_in_lambda_expression3252 = new BitSet(new ulong[]{0x4000000002013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_anonymous_function_body_in_lambda_expression3256 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_88_in_anonymous_function_signature3263 = new BitSet(new ulong[]{0x0000000004000010UL,0x0000000019040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_explicit_anonymous_function_parameter_list_in_anonymous_function_signature3266 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_implicit_anonymous_function_parameter_list_in_anonymous_function_signature3272 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_anonymous_function_signature3276 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_implicit_anonymous_function_parameter_list_in_anonymous_function_signature3281 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3290 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_implicit_anonymous_function_parameter_list3295 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000001000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_implicit_anonymous_function_parameter_in_implicit_anonymous_function_parameter_list3299 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_identifier_in_implicit_anonymous_function_parameter3309 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_anonymous_function_body3316 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_anonymous_function_body3321 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_from_clause_in_query_expression3333 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x000000000002CCA0UL});
    public static readonly BitSet FOLLOW_query_body_in_query_expression3337 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_query_body_clauses_in_query_body3347 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x000000000002CCA0UL});
    public static readonly BitSet FOLLOW_select_or_group_clause_in_query_body3352 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000010UL});
    public static readonly BitSet FOLLOW_query_continuation_in_query_body3363 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_132_in_query_continuation3373 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_query_continuation3377 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x000000000002CCA0UL});
    public static readonly BitSet FOLLOW_query_body_in_query_continuation3381 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_query_body_clause_in_query_body_clauses3388 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000020CA0UL});
    public static readonly BitSet FOLLOW_from_clause_in_query_body_clause3397 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_let_clause_in_query_body_clause3402 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_where_clause_in_query_body_clause3407 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_join_clause_in_query_body_clause3412 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_orderby_clause_in_query_body_clause3417 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_133_in_from_clause3424 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_from_clause3428 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_from_clause3433 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_134_in_from_clause3437 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_from_clause3441 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_135_in_join_clause3449 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_join_clause3453 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_join_clause3458 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_134_in_join_clause3462 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_join_clause3466 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000100UL});
    public static readonly BitSet FOLLOW_136_in_join_clause3470 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_join_clause3474 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000200UL});
    public static readonly BitSet FOLLOW_137_in_join_clause3478 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_join_clause3482 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000010UL});
    public static readonly BitSet FOLLOW_132_in_join_clause3485 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_join_clause3487 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_138_in_let_clause3497 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_let_clause3501 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_let_clause3505 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_let_clause3509 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_139_in_orderby_clause3516 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_ordering_list_in_orderby_clause3520 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ordering_in_ordering_list3528 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_ordering_list3533 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_ordering_in_ordering_list3537 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_expression_in_ordering3547 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000003000UL});
    public static readonly BitSet FOLLOW_ordering_direction_in_ordering3552 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_ordering_direction0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_select_clause_in_select_or_group_clause3574 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_group_clause_in_select_or_group_clause3579 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_142_in_select_clause3587 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_select_clause3591 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_143_in_group_clause3599 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_group_clause3603 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_144_in_group_clause3607 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_group_clause3611 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_145_in_where_clause3619 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_boolean_expression_in_where_clause3623 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_boolean_expression3631 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_global_attribute_in_global_attributes3643 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_86_in_global_attribute3653 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x00000000000C0000UL});
    public static readonly BitSet FOLLOW_global_attribute_target_specifier_in_global_attribute3657 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attribute_list_in_global_attribute3661 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000002800000UL});
    public static readonly BitSet FOLLOW_89_in_global_attribute3665 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_global_attribute3670 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_global_attribute_target_in_global_attribute_target_specifier3679 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_global_attribute_target_specifier3683 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_global_attribute_target0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attribute_sections_in_attributes3705 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attribute_section_in_attribute_sections3714 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_86_in_attribute_section3724 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE7FFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attribute_target_specifier_in_attribute_section3728 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attribute_list_in_attribute_section3733 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000002800000UL});
    public static readonly BitSet FOLLOW_89_in_attribute_section3737 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_attribute_section3742 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attribute_target_in_attribute_target_specifier3751 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_attribute_target_specifier3755 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_attribute_target0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attribute_in_attribute_list3797 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_attribute_list3800 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attribute_in_attribute_list3802 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_type_name_in_attribute3814 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_attribute_arguments_in_attribute3818 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_88_in_attribute_arguments3829 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_RPAREN_in_attribute_arguments3834 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_positional_argument_in_attribute_arguments3854 = new BitSet(new ulong[]{0x0000000004000010UL,0x0000000002000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_named_argument_in_attribute_arguments3873 = new BitSet(new ulong[]{0x0000000004000010UL,0x0000000002000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_89_in_attribute_arguments3889 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_positional_argument_in_attribute_arguments3891 = new BitSet(new ulong[]{0x0000000004000010UL,0x0000000002000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_RPAREN_in_attribute_arguments3902 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_positional_argument_in_positional_argument_list3916 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_positional_argument_list3919 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_positional_argument_in_positional_argument_list3921 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_attribute_argument_expression_in_positional_argument3932 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_named_argument_in_named_argument_list3941 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_named_argument_list3944 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_named_argument_in_named_argument_list3946 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_identifier_in_named_argument3957 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_named_argument3961 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attribute_argument_expression_in_named_argument3965 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_attribute_argument_expression3974 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_155_in_class_declaration3987 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_type_or_generic_in_class_declaration3990 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_class_base_in_class_declaration3994 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clauses_in_class_declaration3999 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_class_body_in_class_declaration4004 = new BitSet(new ulong[]{0x0000000002000002UL});
    public static readonly BitSet FOLLOW_SEMI_in_class_declaration4008 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_90_in_class_base4021 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_interface_type_list_in_class_base4025 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_interface_type_list4035 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_interface_type_list4038 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_interface_type_list4042 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_62_in_class_body4053 = new BitSet(new ulong[]{0xA000000000080010UL,0x000004020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_class_member_declarations_in_class_body4057 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_class_body4062 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_class_member_declaration_in_class_member_declarations4070 = new BitSet(new ulong[]{0x2000000000080012UL,0x000004020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_81_in_constant_declaration4081 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_constant_declaration4085 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_constant_declarators_in_constant_declaration4089 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_constant_declaration4093 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constant_declarator_in_constant_declarators4101 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_constant_declarators4104 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_constant_declarator_in_constant_declarators4106 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_identifier_in_constant_declarator4116 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_constant_declarator4121 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_constant_expression_in_constant_declarator4125 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_constant_expression4135 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_declarators_in_field_declaration4144 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_field_declaration4148 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_declarator_in_variable_declarators4156 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_variable_declarators4159 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_variable_declarator_in_variable_declarators4163 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_type_name_in_variable_declarator4173 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_variable_declarator4176 = new BitSet(new ulong[]{0x4000000000013FF0UL,0x002007D7E16C0012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_variable_initializer_in_variable_declarator4180 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_method_header_in_method_declaration4194 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_method_body_in_method_declaration4198 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_method_header4206 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_method_header4209 = new BitSet(new ulong[]{0x0000000004000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_formal_parameter_list_in_method_header4213 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_method_header4218 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clauses_in_method_header4222 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_method_body4231 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_qid_in_member_name4239 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_property_declaration4251 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_property_declaration4255 = new BitSet(new ulong[]{0x0000000000000000UL,0x00000000004001E0UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_accessor_declarations_in_property_declaration4259 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_property_declaration4263 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attributes_in_accessor_declarations4271 = new BitSet(new ulong[]{0x0000000000000000UL,0x00000000004001E0UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_get_accessor_declaration_in_accessor_declarations4277 = new BitSet(new ulong[]{0x0000000000000002UL,0x00000000004001E0UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_attributes_in_accessor_declarations4281 = new BitSet(new ulong[]{0x0000000000000002UL,0x00000000004001E0UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_set_accessor_declaration_in_accessor_declarations4286 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_accessor_declaration_in_accessor_declarations4293 = new BitSet(new ulong[]{0x0000000000000002UL,0x00000000004001E0UL,0x0000000010000000UL});
    public static readonly BitSet FOLLOW_attributes_in_accessor_declarations4297 = new BitSet(new ulong[]{0x0000000000000002UL,0x00000000000001E0UL,0x0000000010000000UL});
    public static readonly BitSet FOLLOW_get_accessor_declaration_in_accessor_declarations4302 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_accessor_modifier_in_get_accessor_declaration4312 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000010000000UL});
    public static readonly BitSet FOLLOW_156_in_get_accessor_declaration4317 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_accessor_body_in_get_accessor_declaration4321 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_accessor_modifier_in_set_accessor_declaration4329 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000020000000UL});
    public static readonly BitSet FOLLOW_157_in_set_accessor_declaration4334 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_accessor_body_in_set_accessor_declaration4338 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_accessor_modifier0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_accessor_body4366 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_149_in_event_declaration4376 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_event_declaration4380 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_member_name_in_event_declaration4395 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_event_declaration4399 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x00000000C0000000UL});
    public static readonly BitSet FOLLOW_event_accessor_declarations_in_event_declaration4403 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_event_declaration4407 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variable_declarators_in_event_declaration4413 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_event_declaration4417 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_modifier_in_event_modifiers4429 = new BitSet(new ulong[]{0x0000000000000002UL,0x000000000001FFF1UL});
    public static readonly BitSet FOLLOW_attributes_in_event_accessor_declarations4438 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x00000000C0000000UL});
    public static readonly BitSet FOLLOW_add_accessor_declaration_in_event_accessor_declarations4445 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x00000000C0000000UL});
    public static readonly BitSet FOLLOW_attributes_in_event_accessor_declarations4449 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x00000000C0000000UL});
    public static readonly BitSet FOLLOW_remove_accessor_declaration_in_event_accessor_declarations4454 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_remove_accessor_declaration_in_event_accessor_declarations4475 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x0000000040000000UL});
    public static readonly BitSet FOLLOW_attributes_in_event_accessor_declarations4479 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000040000000UL});
    public static readonly BitSet FOLLOW_add_accessor_declaration_in_event_accessor_declarations4484 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_158_in_add_accessor_declaration4494 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_add_accessor_declaration4498 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_159_in_remove_accessor_declaration4506 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_remove_accessor_declaration4510 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ENUM_in_enum_declaration4522 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_enum_declaration4526 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_enum_base_in_enum_declaration4530 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_enum_body_in_enum_declaration4535 = new BitSet(new ulong[]{0x0000000002000002UL});
    public static readonly BitSet FOLLOW_SEMI_in_enum_declaration4539 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_90_in_enum_base4548 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x000001FF00000000UL});
    public static readonly BitSet FOLLOW_integral_type_in_enum_base4552 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_enum_body4560 = new BitSet(new ulong[]{0x8000000000000010UL,0x0000000000400002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_enum_member_declarations_in_enum_body4563 = new BitSet(new ulong[]{0x8000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_enum_body4565 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_enum_body4572 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_enum_member_declaration_in_enum_member_declarations4580 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_enum_member_declarations4583 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000400002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_enum_member_declaration_in_enum_member_declarations4585 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_attributes_in_enum_member_declaration4595 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_enum_member_declaration4600 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_enum_member_declaration4605 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_enum_member_declaration4609 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_integral_type0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_97_in_delegate_declaration4666 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_return_type_in_delegate_declaration4670 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_delegate_declaration4674 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000801000000UL});
    public static readonly BitSet FOLLOW_variant_generic_parameter_list_in_delegate_declaration4677 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_delegate_declaration4685 = new BitSet(new ulong[]{0x0000000004000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_formal_parameter_list_in_delegate_declaration4689 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_delegate_declaration4694 = new BitSet(new ulong[]{0x0000000002000000UL,0x0000000000000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clauses_in_delegate_declaration4698 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_delegate_declaration4703 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_modifier_in_delegate_modifiers4711 = new BitSet(new ulong[]{0x0000000000000002UL,0x000000000001FFF1UL});
    public static readonly BitSet FOLLOW_99_in_variant_generic_parameter_list4721 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000008400002UL,0x00060400E5DFFFF0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_variant_type_parameters_in_variant_generic_parameter_list4725 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_GT_in_variant_generic_parameter_list4729 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variant_type_variable_name_in_variant_type_parameters4737 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_variant_type_parameters4740 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000008400002UL,0x00060400E5DFFFF0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_variant_type_variable_name_in_variant_type_parameters4742 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_attributes_in_variant_type_variable_name4752 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000008400002UL,0x00060400E5DFFFF0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_variance_annotation_in_variant_type_variable_name4757 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000008400002UL,0x00060400E5DFFFF0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_type_variable_name_in_variant_type_variable_name4762 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_variance_annotation0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clause_in_type_parameter_constraints_clauses4783 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_type_parameter_constraints_clauses4788 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clause_in_type_parameter_constraints_clauses4792 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_145_in_type_parameter_constraints_clause4802 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000008400002UL,0x00060400E5DFFFF0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_type_variable_name_in_type_parameter_constraints_clause4806 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_type_parameter_constraints_clause4810 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000012UL,0x000607FFEDDFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_parameter_constraint_list_in_type_parameter_constraints_clause4814 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_type_parameter_constraint_list4877 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_type_parameter_constraint_list4888 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_secondary_constraint_list_in_type_parameter_constraint_list4892 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_type_parameter_constraint_list4899 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000012UL,0x000607FFEDDFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_constructor_constraint_in_type_parameter_constraint_list4903 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_secondary_constraint_list_in_type_parameter_constraint_list4910 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_type_parameter_constraint_list4915 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000012UL,0x000607FFEDDFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_constructor_constraint_in_type_parameter_constraint_list4919 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constructor_constraint_in_type_parameter_constraint_list4926 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_secondary_constraint_in_secondary_constraint_list4938 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_secondary_constraint_list4941 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_secondary_constraint_in_secondary_constraint_list4943 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_type_name_in_secondary_constraint4953 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_type_variable_name4963 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_68_in_constructor_constraint4971 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_constructor_constraint4975 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_constructor_constraint4979 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_return_type4987 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_82_in_return_type4993 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_formal_parameter_in_formal_parameter_list5000 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_formal_parameter_list5003 = new BitSet(new ulong[]{0x0000000000000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_formal_parameter_in_formal_parameter_list5005 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_attributes_in_formal_parameter5015 = new BitSet(new ulong[]{0x0000000000000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_fixed_parameter_in_formal_parameter5021 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_parameter_array_in_formal_parameter5025 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_170_in_formal_parameter5032 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_fixed_parameter_in_fixed_parameters5040 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_fixed_parameters5045 = new BitSet(new ulong[]{0x0000000000000010UL,0x00000000180C0002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_fixed_parameter_in_fixed_parameters5049 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_parameter_modifier_in_fixed_parameter5060 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_fixed_parameter5065 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_fixed_parameter5069 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_default_argument_in_fixed_parameter5073 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_66_in_default_argument5083 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_default_argument5085 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_parameter_modifier0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_171_in_parameter_array5108 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_parameter_array5112 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_parameter_array5116 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_172_in_interface_declaration5126 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_interface_declaration5130 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000804000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_variant_generic_parameter_list_in_interface_declaration5134 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000804000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_interface_base_in_interface_declaration5143 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000804000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clauses_in_interface_declaration5148 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000804000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_interface_body_in_interface_declaration5153 = new BitSet(new ulong[]{0x0000000002000002UL});
    public static readonly BitSet FOLLOW_SEMI_in_interface_declaration5157 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_modifier_in_interface_modifiers5167 = new BitSet(new ulong[]{0x0000000000000002UL,0x000000000001FFF1UL});
    public static readonly BitSet FOLLOW_90_in_interface_base5180 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_interface_type_list_in_interface_base5182 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_interface_body5190 = new BitSet(new ulong[]{0x8000000000000010UL,0x000000000045FFF3UL,0x000605FFE5FFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_interface_member_declarations_in_interface_body5194 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_interface_body5199 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_member_declaration_in_interface_member_declarations5207 = new BitSet(new ulong[]{0x0000000000000012UL,0x000000000045FFF3UL,0x000605FFE5FFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attributes_in_interface_member_declaration5216 = new BitSet(new ulong[]{0x0000000000000010UL,0x000000000005FFF3UL,0x000605FFE5FFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_modifiers_in_interface_member_declaration5222 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5FFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_82_in_interface_member_declaration5228 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_interface_method_declaration_in_interface_member_declaration5232 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_event_declaration_in_interface_member_declaration5238 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_interface_member_declaration5244 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000080002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_interface_method_declaration_in_interface_member_declaration5260 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_property_declaration_in_interface_member_declaration5285 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_indexer_declaration_in_interface_member_declaration5295 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_interface_property_declaration5312 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_interface_property_declaration5316 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_interface_accessor_declarations_in_interface_property_declaration5320 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_interface_property_declaration5324 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_interface_method_declaration5332 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000801000000UL});
    public static readonly BitSet FOLLOW_generic_argument_list_in_interface_method_declaration5336 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_interface_method_declaration5344 = new BitSet(new ulong[]{0x0000000004000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_formal_parameter_list_in_interface_method_declaration5348 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_interface_method_declaration5353 = new BitSet(new ulong[]{0x0000000002000000UL,0x0000000000000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clauses_in_interface_method_declaration5357 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_interface_method_declaration5362 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_149_in_interface_event_declaration5373 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_interface_event_declaration5377 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_interface_event_declaration5381 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_interface_event_declaration5385 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_83_in_interface_indexer_declaration5397 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_86_in_interface_indexer_declaration5401 = new BitSet(new ulong[]{0x0000000000000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_formal_parameter_list_in_interface_indexer_declaration5405 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_interface_indexer_declaration5409 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_interface_indexer_declaration5413 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_interface_accessor_declarations_in_interface_indexer_declaration5417 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_interface_indexer_declaration5421 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_attributes_in_interface_accessor_declarations5429 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_interface_get_accessor_declaration_in_interface_accessor_declarations5438 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000400000UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_attributes_in_interface_accessor_declarations5442 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000400000UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_interface_set_accessor_declaration_in_interface_accessor_declarations5447 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_set_accessor_declaration_in_interface_accessor_declarations5454 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000400000UL,0x0000000010000000UL});
    public static readonly BitSet FOLLOW_attributes_in_interface_accessor_declarations5458 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000010000000UL});
    public static readonly BitSet FOLLOW_interface_get_accessor_declaration_in_interface_accessor_declarations5463 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_156_in_interface_get_accessor_declaration5473 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_interface_get_accessor_declaration5477 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_157_in_interface_set_accessor_declaration5487 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_interface_set_accessor_declaration5491 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_modifier_in_method_modifiers5501 = new BitSet(new ulong[]{0x0000000000000002UL,0x000000000001FFF1UL});
    public static readonly BitSet FOLLOW_169_in_struct_declaration5513 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_type_or_generic_in_struct_declaration5517 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_struct_interfaces_in_struct_declaration5521 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_type_parameter_constraints_clauses_in_struct_declaration5526 = new BitSet(new ulong[]{0x4000000000000000UL,0x0000000004000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_struct_body_in_struct_declaration5531 = new BitSet(new ulong[]{0x0000000002000002UL});
    public static readonly BitSet FOLLOW_SEMI_in_struct_declaration5535 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_modifier_in_struct_modifiers5544 = new BitSet(new ulong[]{0x0000000000000002UL,0x00000000000003F0UL});
    public static readonly BitSet FOLLOW_set_in_struct_modifier0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_90_in_struct_interfaces5581 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_interface_type_list_in_struct_interfaces5585 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_struct_body5592 = new BitSet(new ulong[]{0xA000000000080010UL,0x000000020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_struct_member_declarations_in_struct_body5596 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_struct_body5601 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_member_declaration_in_struct_member_declarations5608 = new BitSet(new ulong[]{0x2000000000080012UL,0x000000020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attributes_in_struct_member_declaration5617 = new BitSet(new ulong[]{0x2000000000080010UL,0x000000020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_modifiers_in_struct_member_declaration5624 = new BitSet(new ulong[]{0x2000000000080010UL,0x000000020047FFFBUL,0x0006D7FFEDFFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_81_in_struct_member_declaration5630 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_struct_member_declaration5634 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_constant_declarators_in_struct_member_declaration5638 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_struct_member_declaration5642 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_event_declaration_in_struct_member_declaration5647 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_67_in_struct_member_declaration5654 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000617FFEDDFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_method_declaration_in_struct_member_declaration5657 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_declaration_in_struct_member_declaration5668 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_class_declaration_in_struct_member_declaration5679 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_declaration_in_struct_member_declaration5690 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_interface_declaration_in_struct_member_declaration5697 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_class_declaration_in_struct_member_declaration5703 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_82_in_struct_member_declaration5710 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_method_declaration_in_struct_member_declaration5714 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_struct_member_declaration5719 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000080002UL,0x000625FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_method_declaration_in_struct_member_declaration5733 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_property_declaration_in_struct_member_declaration5752 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_name_in_struct_member_declaration5775 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_DOT_in_struct_member_declaration5777 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000080000UL});
    public static readonly BitSet FOLLOW_indexer_declaration_in_struct_member_declaration5779 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_indexer_declaration_in_struct_member_declaration5788 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_field_declaration_in_struct_member_declaration5801 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_operator_declaration_in_struct_member_declaration5819 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_struct_declaration_in_struct_member_declaration5837 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_enum_declaration_in_struct_member_declaration5843 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_delegate_declaration_in_struct_member_declaration5850 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conversion_operator_declaration_in_struct_member_declaration5856 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constructor_declaration_in_struct_member_declaration5861 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_indexer_declarator_in_indexer_declaration5878 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_indexer_declaration5882 = new BitSet(new ulong[]{0x0000000000000000UL,0x00000000004001E0UL,0x0000000030000000UL});
    public static readonly BitSet FOLLOW_accessor_declarations_in_indexer_declaration5886 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_indexer_declaration5890 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_83_in_indexer_declarator5900 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_86_in_indexer_declarator5904 = new BitSet(new ulong[]{0x0000000000000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_formal_parameter_list_in_indexer_declarator5908 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_indexer_declarator5912 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_operator_declarator_in_operator_declaration5923 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_operator_body_in_operator_declaration5927 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_173_in_operator_declarator5935 = new BitSet(new ulong[]{0x0000000000031800UL,0xF3F007D800000000UL});
    public static readonly BitSet FOLLOW_set_in_operator_declarator5943 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_operator_declarator5953 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_operator_declarator5957 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_operator_declarator5961 = new BitSet(new ulong[]{0x0000000004000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_binary_operator_declarator_in_operator_declarator5964 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_operator_declarator_in_operator_declarator5968 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_overloadable_unary_operator_in_operator_declarator5975 = new BitSet(new ulong[]{0x0000000004000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_unary_operator_declarator_in_operator_declarator5979 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_overloadable_binary_operator_in_operator_declarator5985 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_binary_operator_declarator_in_operator_declarator5989 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_RPAREN_in_unary_operator_declarator6001 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_overloadable_unary_operator0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_89_in_binary_operator_declarator6044 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_binary_operator_declarator6048 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_binary_operator_declarator6052 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_binary_operator_declarator6056 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_100_in_overloadable_binary_operator6067 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_118_in_overloadable_binary_operator6071 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_119_in_overloadable_binary_operator6075 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_117_in_overloadable_binary_operator6079 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_127_in_overloadable_binary_operator6083 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_126_in_overloadable_binary_operator6087 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_120_in_overloadable_binary_operator6091 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_GT_in_overloadable_binary_operator6095 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_GT_in_overloadable_binary_operator6097 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_124_in_overloadable_binary_operator6101 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_125_in_overloadable_binary_operator6105 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_GT_in_overloadable_binary_operator6109 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_99_in_overloadable_binary_operator6113 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_116_in_overloadable_binary_operator6117 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_121_in_overloadable_binary_operator6121 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_conversion_operator_declarator_in_conversion_operator_declaration6131 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_operator_body_in_conversion_operator_declaration6135 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_conversion_operator_declarator6143 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000200000000000UL});
    public static readonly BitSet FOLLOW_173_in_conversion_operator_declarator6152 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_conversion_operator_declarator6156 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_conversion_operator_declarator6160 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_conversion_operator_declarator6164 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_conversion_operator_declarator6168 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_conversion_operator_declarator6172 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_operator_body6180 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_constructor_declarator_in_constructor_declaration6190 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_constructor_body_in_constructor_declaration6194 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_constructor_declarator6202 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_constructor_declarator6206 = new BitSet(new ulong[]{0x0000000004000010UL,0x00000000184C0002UL,0x00060DFFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_formal_parameter_list_in_constructor_declarator6210 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_constructor_declarator6215 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_constructor_initializer_in_constructor_declarator6219 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_90_in_constructor_initializer6228 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000280000UL});
    public static readonly BitSet FOLLOW_set_in_constructor_initializer6232 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_constructor_initializer6242 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7F9280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_argument_list_in_constructor_initializer6246 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_constructor_initializer6251 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_constructor_body6259 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_106_in_destructor_declaration6275 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_destructor_declaration6278 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_destructor_declaration6282 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_destructor_declaration6286 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_destructor_body_in_destructor_declaration6291 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_destructor_body6299 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_invocation_start_in_invocation_expression6309 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_arguments_in_invocation_expression6331 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_invocation_part_in_invocation_expression6335 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_invocation_part_in_invocation_expression6346 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000001400000UL});
    public static readonly BitSet FOLLOW_arguments_in_invocation_expression6352 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_predefined_type_in_invocation_start6360 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_invocation_start6377 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_generic_argument_list_in_invocation_start6381 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_83_in_invocation_start6386 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_85_in_invocation_start6392 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_invocation_start6397 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000100000UL});
    public static readonly BitSet FOLLOW_84_in_invocation_start6402 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_invocation_start6406 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeof_expression_in_invocation_start6413 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_access_identifier_in_invocation_part6436 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_brackets_in_invocation_part6441 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_declaration_statement_in_statement6458 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_labeled_statement_in_statement6473 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_embedded_statement_in_statement6478 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_embedded_statement6488 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_selection_statement_in_embedded_statement6493 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_iteration_statement_in_embedded_statement6499 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_jump_statement_in_embedded_statement6505 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_try_statement_in_embedded_statement6512 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_checked_statement_in_embedded_statement6517 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unchecked_statement_in_embedded_statement6522 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_lock_statement_in_embedded_statement6527 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_using_statement_in_embedded_statement6532 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_yield_statement_in_embedded_statement6538 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unsafe_statement_in_embedded_statement6544 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_fixed_statement_in_embedded_statement6549 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_statement_in_embedded_statement6554 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_176_in_fixed_statement6564 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_fixed_statement6568 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_pointer_type_in_fixed_statement6572 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_fixed_pointer_declarators_in_fixed_statement6574 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_fixed_statement6578 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_fixed_statement6582 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_fixed_pointer_declarator_in_fixed_pointer_declarators6590 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_fixed_pointer_declarators6595 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_fixed_pointer_declarator_in_fixed_pointer_declarators6599 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_identifier_in_fixed_pointer_declarator6609 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_fixed_pointer_declarator6613 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_fixed_pointer_initializer_in_fixed_pointer_declarator6617 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_fixed_pointer_initializer6627 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_73_in_unsafe_statement6634 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_unsafe_statement6638 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_labeled_statement6645 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_labeled_statement6649 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_statement_in_labeled_statement6653 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_local_variable_declaration_in_declaration_statement6662 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_local_constant_declaration_in_declaration_statement6668 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_declaration_statement6671 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_local_variable_type_in_local_variable_declaration6679 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_local_variable_declarators_in_local_variable_declaration6683 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_177_in_local_variable_type6697 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_178_in_local_variable_type6708 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_type_in_local_variable_type6713 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_local_variable_declarator_in_local_variable_declarators6721 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_local_variable_declarators6724 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_local_variable_declarator_in_local_variable_declarators6726 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_identifier_in_local_variable_declarator6736 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_local_variable_declarator6739 = new BitSet(new ulong[]{0x4000000000013FF0UL,0x002007D7E16C0012UL,0x000E05FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_local_variable_initializer_in_local_variable_declarator6743 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_local_variable_initializer6754 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_array_initializer_in_local_variable_initializer6759 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_stackalloc_initializer_in_local_variable_initializer6765 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_179_in_stackalloc_initializer6772 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unmanaged_type_in_stackalloc_initializer6776 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_86_in_stackalloc_initializer6780 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_stackalloc_initializer6784 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000800000UL});
    public static readonly BitSet FOLLOW_87_in_stackalloc_initializer6788 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_81_in_local_constant_declaration6796 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_local_constant_declaration6800 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_constant_declarators_in_local_constant_declaration6804 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_expression_statement6812 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_expression_statement6816 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_statement_expression6826 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_if_statement_in_selection_statement6835 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_switch_statement_in_selection_statement6840 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_IF_in_if_statement6850 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_if_statement6854 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_boolean_expression_in_if_statement6858 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_if_statement6862 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_if_statement6866 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0010000000000000UL});
    public static readonly BitSet FOLLOW_else_statement_in_if_statement6875 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_180_in_else_statement6886 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_else_statement6890 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_181_in_switch_statement6898 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_switch_statement6902 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_switch_statement6906 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_switch_statement6910 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_switch_block_in_switch_statement6914 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_62_in_switch_block6922 = new BitSet(new ulong[]{0x8000000000000000UL,0x0000000100000000UL,0x0040000000000000UL});
    public static readonly BitSet FOLLOW_switch_sections_in_switch_block6926 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_63_in_switch_block6931 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_switch_section_in_switch_sections6939 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000100000000UL,0x0040000000000000UL});
    public static readonly BitSet FOLLOW_switch_labels_in_switch_section6948 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_statement_list_in_switch_section6952 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_switch_label_in_switch_labels6960 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000100000000UL,0x0040000000000000UL});
    public static readonly BitSet FOLLOW_182_in_switch_label6970 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_constant_expression_in_switch_label6974 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_switch_label6978 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_96_in_switch_label6985 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_switch_label6989 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_while_statement_in_iteration_statement6998 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_do_statement_in_iteration_statement7003 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_for_statement_in_iteration_statement7008 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_foreach_statement_in_iteration_statement7013 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_183_in_while_statement7021 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_while_statement7025 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_boolean_expression_in_while_statement7029 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_while_statement7033 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_while_statement7037 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_184_in_do_statement7045 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_do_statement7049 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0080000000000000UL});
    public static readonly BitSet FOLLOW_183_in_do_statement7053 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_do_statement7057 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_boolean_expression_in_do_statement7061 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_do_statement7065 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_do_statement7069 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_185_in_for_statement7077 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_for_statement7081 = new BitSet(new ulong[]{0x0000000002013FF0UL,0x002007D7E12C0012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_for_initializer_in_for_statement7085 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_for_statement7090 = new BitSet(new ulong[]{0x0000000002013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_for_condition_in_for_statement7094 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_for_statement7099 = new BitSet(new ulong[]{0x0000000004013FF0UL,0x002007D7E12C0012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_for_iterator_in_for_statement7103 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_for_statement7108 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_for_statement7112 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_local_variable_declaration_in_for_initializer7126 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_statement_expression_list_in_for_initializer7131 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_boolean_expression_in_for_condition7141 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_statement_expression_list_in_for_iterator7149 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_statement_expression_in_statement_expression_list7157 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_89_in_statement_expression_list7160 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E12C0012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_statement_expression_in_statement_expression_list7162 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_186_in_foreach_statement7172 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_foreach_statement7176 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_local_variable_type_in_foreach_statement7180 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_foreach_statement7184 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_134_in_foreach_statement7188 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_foreach_statement7192 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_foreach_statement7196 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_foreach_statement7200 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_break_statement_in_jump_statement7208 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_continue_statement_in_jump_statement7213 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_goto_statement_in_jump_statement7218 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_return_statement_in_jump_statement7223 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_throw_statement_in_jump_statement7228 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_187_in_break_statement7236 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_break_statement7240 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_188_in_continue_statement7248 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_continue_statement7252 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_189_in_goto_statement7260 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000100000002UL,0x00460400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_goto_statement7266 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_182_in_goto_statement7274 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_constant_expression_in_goto_statement7278 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_96_in_goto_statement7286 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_goto_statement7291 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_153_in_return_statement7299 = new BitSet(new ulong[]{0x0000000002013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_return_statement7303 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_return_statement7308 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_190_in_throw_statement7316 = new BitSet(new ulong[]{0x0000000002013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_throw_statement7320 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_throw_statement7325 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_191_in_try_statement7338 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_try_statement7342 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000000UL,0x0000000000000003UL});
    public static readonly BitSet FOLLOW_catch_clauses_in_try_statement7348 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000000UL,0x0000000000000003UL});
    public static readonly BitSet FOLLOW_finally_clause_in_try_statement7352 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_finally_clause_in_try_statement7364 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_192_in_catch_clauses7373 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_specific_catch_clauses_in_catch_clauses7378 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_general_catch_clause_in_catch_clauses7382 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_specific_catch_clause_in_specific_catch_clauses7391 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000000UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_192_in_specific_catch_clauses7396 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_specific_catch_clause_in_specific_catch_clauses7401 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000000UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_general_catch_clause_in_specific_catch_clauses7405 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000000UL,0x0000000000000000UL,0x0000000000000001UL});
    public static readonly BitSet FOLLOW_88_in_specific_catch_clause7415 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_class_type_in_specific_catch_clause7419 = new BitSet(new ulong[]{0x0000000004000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_specific_catch_clause7423 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_specific_catch_clause7428 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_specific_catch_clause7432 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_block_in_general_catch_clause7440 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_193_in_finally_clause7448 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_finally_clause7452 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_94_in_checked_statement7460 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_checked_statement7464 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_95_in_unchecked_statement7472 = new BitSet(new ulong[]{0x4000000002000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_block_in_unchecked_statement7476 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_194_in_lock_statement7484 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_lock_statement7488 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_lock_statement7491 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_lock_statement7495 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_lock_statement7499 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_USING_in_using_statement7507 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_using_statement7511 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E12C0012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_resource_acquisition_in_using_statement7516 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_using_statement7520 = new BitSet(new ulong[]{0x4000000002153FF0UL,0x002007D7E12E0212UL,0xFFA705FFE7DFFFB0UL,0x00000000000007FCUL});
    public static readonly BitSet FOLLOW_embedded_statement_in_using_statement7525 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_local_variable_declaration_in_resource_acquisition7539 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_resource_acquisition7544 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_195_in_yield_statement7552 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0800000002000000UL});
    public static readonly BitSet FOLLOW_153_in_yield_statement7557 = new BitSet(new ulong[]{0x0000000000013FF0UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_yield_statement7561 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_yield_statement7565 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_187_in_yield_statement7580 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_yield_statement7584 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_predefined_type0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_identifier0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_keyword0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_also_keyword0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_literal0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignment_in_assignment_list10280 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_assignment_list10282 = new BitSet(new ulong[]{0x0000000000013FF2UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attributes_in_field_declarations10293 = new BitSet(new ulong[]{0x0000000000000010UL,0x000000000005FFF3UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_modifiers_in_field_declarations10298 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_field_declarations10303 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_field_declaration_in_field_declarations10307 = new BitSet(new ulong[]{0x0000000000000012UL,0x000000000045FFF3UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attributes_in_property_declaration_list10318 = new BitSet(new ulong[]{0x0000000000000010UL,0x000000000005FFF3UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_modifiers_in_property_declaration_list10323 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_property_declaration_list10328 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_property_declaration_in_property_declaration_list10332 = new BitSet(new ulong[]{0x0000000000000012UL,0x000000000045FFF3UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_constant_declaration_in_constant_declarations10342 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_literal_in_literals10350 = new BitSet(new ulong[]{0x0000000000003FF2UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_attributes_in_delegate_declaration_list10360 = new BitSet(new ulong[]{0x2000000000080000UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_modifiers_in_delegate_declaration_list10365 = new BitSet(new ulong[]{0x2000000000080000UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_delegate_declaration_in_delegate_declaration_list10370 = new BitSet(new ulong[]{0x2000000000080002UL,0x000000020041FFF9UL,0x0000120008000000UL});
    public static readonly BitSet FOLLOW_local_variable_declaration_in_local_variable_declaration_list10381 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_local_variable_declaration_list10383 = new BitSet(new ulong[]{0x0000000000000012UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_local_variable_initializer_in_local_variable_initializer_list10394 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_local_variable_initializer_list10396 = new BitSet(new ulong[]{0x4000000000013FF2UL,0x002007D7E16C0012UL,0x000E05FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_expression_in_expression_list_test10407 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_expression_list_test10409 = new BitSet(new ulong[]{0x0000000000013FF2UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_unary_expression_in_unary_expression_list10420 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_unary_expression_list10422 = new BitSet(new ulong[]{0x0000000000013FF2UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_invocation_expression_in_invocation_expression_list10433 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_invocation_expression_list10435 = new BitSet(new ulong[]{0x0000000000000012UL,0x0000000400280002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_primary_expression_in_primary_expression_list10446 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_primary_expression_list10448 = new BitSet(new ulong[]{0x0000000000003FF2UL,0x00000007E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_non_assignment_expression_in_non_assignment_expression_list10459 = new BitSet(new ulong[]{0x0000000002000000UL});
    public static readonly BitSet FOLLOW_SEMI_in_non_assignment_expression_list10461 = new BitSet(new ulong[]{0x0000000000013FF2UL,0x002007D7E1280012UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_modifiers_in_method_declarations10472 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_82_in_method_declarations10476 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_method_declarations10480 = new BitSet(new ulong[]{0x0000000000003FF0UL,0x0000000000000002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_method_declaration_in_method_declarations10483 = new BitSet(new ulong[]{0x0000000000000012UL,0x000000000005FFF3UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_67_in_synpred1_cs285 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred2_cs549 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_synpred2_cs553 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred3_cs568 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_synpred3_cs572 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred4_cs587 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_DOT_in_synpred4_cs591 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000080000UL});
    public static readonly BitSet FOLLOW_83_in_synpred4_cs595 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_83_in_synpred5_cs715 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_brackets_in_synpred5_cs720 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_85_in_synpred6_cs740 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_brackets_in_synpred6_cs744 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_object_creation_expression_in_synpred7_cs780 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_set_in_synpred7_cs784 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_delegate_creation_expression_in_synpred8_cs828 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_synpred9_cs953 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_99_in_synpred9_cs958 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_88_in_synpred10_cs1210 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000040002UL,0x000605FFE5DFFFB0UL,0x00000000000007F8UL});
    public static readonly BitSet FOLLOW_type_in_synpred10_cs1214 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_RPAREN_in_synpred10_cs1218 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_array_creation_expression_in_synpred11_cs1460 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_arguments_in_synpred12_cs1540 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_set_in_synpred12_cs1544 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unbound_type_name_in_synpred13_cs2070 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_generic_dimension_specifier_in_synpred14_cs2128 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_DOT_in_synpred14_cs2132 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_synpred15_cs2264 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_99_in_synpred15_cs2268 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_synpred16_cs2313 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_99_in_synpred16_cs2318 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_predefined_type_in_synpred17_cs2411 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_type_name_in_synpred17_cs2415 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_rank_specifiers_in_synpred17_cs2419 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_predefined_type_in_synpred18_cs2446 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000003000000000UL});
    public static readonly BitSet FOLLOW_type_name_in_synpred18_cs2450 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000003000000000UL});
    public static readonly BitSet FOLLOW_100_in_synpred18_cs2455 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000001000000000UL});
    public static readonly BitSet FOLLOW_101_in_synpred18_cs2460 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unary_expression_in_synpred19_cs2642 = new BitSet(new ulong[]{0x0000000000020000UL,0x000FF80000000004UL});
    public static readonly BitSet FOLLOW_assignment_operator_in_synpred19_cs2646 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_cast_expression_in_synpred20_cs2704 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_anonymous_function_signature_in_synpred21_cs2920 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000000UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_131_in_synpred21_cs2924 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_query_expression_in_synpred22_cs2935 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_132_in_synpred23_cs3358 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_89_in_synpred24_cs3860 = new BitSet(new ulong[]{0x0000000000000010UL,0x0000000000000002UL,0x00060400E5DFFFB0UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_identifier_in_synpred24_cs3864 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000004UL});
    public static readonly BitSet FOLLOW_66_in_synpred24_cs3868 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred25_cs4386 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_synpred25_cs4390 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred26_cs5251 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_synpred26_cs5255 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred27_cs5276 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_synpred27_cs5280 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred28_cs5724 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_synpred28_cs5728 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred29_cs5743 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_62_in_synpred29_cs5747 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_member_name_in_synpred30_cs5762 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_DOT_in_synpred30_cs5766 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000080000UL});
    public static readonly BitSet FOLLOW_83_in_synpred30_cs5770 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_arguments_in_synpred31_cs6316 = new BitSet(new ulong[]{0x000000000000C000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_set_in_synpred31_cs6320 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_synpred32_cs6367 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000800000000UL});
    public static readonly BitSet FOLLOW_99_in_synpred32_cs6372 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_declaration_statement_in_synpred33_cs6453 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_synpred34_cs6464 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000004000000UL});
    public static readonly BitSet FOLLOW_90_in_synpred34_cs6468 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_177_in_synpred35_cs6692 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_178_in_synpred36_cs6703 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_180_in_synpred37_cs6870 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_local_variable_declaration_in_synpred38_cs7121 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_local_variable_declaration_in_synpred39_cs7534 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}